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


1930db7d8217b9cbec2c90fa89a032c6bb5b1109
[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_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 // Pull the nested class out to the top level for SWIG's sake
3487 #define wxImage_RGBValue wxImage::RGBValue
3488 #define wxImage_HSVValue wxImage::HSVValue
3489
3490 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3491 if (width > 0 && height > 0)
3492 return new wxImage(width, height, clear);
3493 else
3494 return new wxImage;
3495 }
3496 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3497 return new wxImage(bitmap.ConvertToImage());
3498 }
3499 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3500 if (DATASIZE != width*height*3) {
3501 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3502 return NULL;
3503 }
3504
3505 // Copy the source data so the wxImage can clean it up later
3506 buffer copy = (buffer)malloc(DATASIZE);
3507 if (copy == NULL) {
3508 wxPyBLOCK_THREADS(PyErr_NoMemory());
3509 return NULL;
3510 }
3511 memcpy(copy, data, DATASIZE);
3512 return new wxImage(width, height, copy, false);
3513 }
3514 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3515 if (DATASIZE != width*height*3) {
3516 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3517 return NULL;
3518 }
3519 if (ALPHASIZE != width*height) {
3520 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3521 return NULL;
3522 }
3523
3524 // Copy the source data so the wxImage can clean it up later
3525 buffer dcopy = (buffer)malloc(DATASIZE);
3526 if (dcopy == NULL) {
3527 wxPyBLOCK_THREADS(PyErr_NoMemory());
3528 return NULL;
3529 }
3530 memcpy(dcopy, data, DATASIZE);
3531
3532 buffer acopy = (buffer)malloc(ALPHASIZE);
3533 if (acopy == NULL) {
3534 wxPyBLOCK_THREADS(PyErr_NoMemory());
3535 return NULL;
3536 }
3537 memcpy(acopy, alpha, ALPHASIZE);
3538
3539 return new wxImage(width, height, dcopy, acopy, false);
3540 }
3541 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3542 wxSize size(self->GetWidth(), self->GetHeight());
3543 return size;
3544 }
3545 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 buffer copy = (buffer)malloc(DATASIZE);
3558 if (copy == NULL) {
3559 wxPyBLOCK_THREADS(PyErr_NoMemory());
3560 return;
3561 }
3562 memcpy(copy, data, DATASIZE);
3563 self->SetData(copy, false);
3564 // wxImage takes ownership of copy...
3565 }
3566 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3567 buffer data = self->GetData();
3568 int len = self->GetWidth() * self->GetHeight() * 3;
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3571 return rv;
3572 }
3573 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3574 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3575 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3576 return;
3577 }
3578 self->SetData(data, true);
3579 }
3580 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3581 buffer data = self->GetAlpha();
3582 if (! data) {
3583 RETURN_NONE();
3584 } else {
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3588 return rv;
3589 }
3590 }
3591 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 buffer acopy = (buffer)malloc(ALPHASIZE);
3597 if (acopy == NULL) {
3598 wxPyBLOCK_THREADS(PyErr_NoMemory());
3599 return;
3600 }
3601 memcpy(acopy, alpha, ALPHASIZE);
3602 self->SetAlpha(acopy, false);
3603 // wxImage takes ownership of acopy...
3604 }
3605 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3606 buffer data = self->GetAlpha();
3607 int len = self->GetWidth() * self->GetHeight();
3608 PyObject* rv;
3609 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3610 return rv;
3611 }
3612 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3613 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3614 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3615 return;
3616 }
3617 self->SetAlpha(alpha, true);
3618 }
3619 SWIGINTERN PyObject *wxImage_GetHandlers(){
3620 wxList& list = wxImage::GetHandlers();
3621 return wxPy_ConvertList(&list);
3622 }
3623 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3624 wxBitmap bitmap(*self, depth);
3625 return bitmap;
3626 }
3627 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3628 wxImage mono = self->ConvertToMono( red, green, blue );
3629 wxBitmap bitmap( mono, 1 );
3630 return bitmap;
3631 }
3632
3633 wxImage* _ImageFromBuffer(int width, int height,
3634 buffer data, int DATASIZE,
3635 buffer alpha=NULL, int ALPHASIZE=0)
3636 {
3637 if (DATASIZE != width*height*3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return NULL;
3640 }
3641 if (alpha != NULL) {
3642 if (ALPHASIZE != width*height) {
3643 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3644 return NULL;
3645 }
3646 return new wxImage(width, height, data, alpha, true);
3647 }
3648 return new wxImage(width, height, data, true);
3649 }
3650
3651 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3652 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3653 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3655 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3659 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3660 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3661 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3662 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3663 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3664 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3665 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3666
3667 #include <wx/quantize.h>
3668
3669 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3670 return wxQuantize::Quantize(src, dest,
3671 //NULL, // palette
3672 desiredNoColours,
3673 NULL, // eightBitData
3674 flags);
3675 }
3676 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3677 if (PyCallable_Check(func)) {
3678 self->Connect(id, lastId, eventType,
3679 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3680 new wxPyCallback(func));
3681 }
3682 else if (func == Py_None) {
3683 self->Disconnect(id, lastId, eventType,
3684 (wxObjectEventFunction)
3685 &wxPyCallback::EventThunker);
3686 }
3687 else {
3688 wxPyBLOCK_THREADS(
3689 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3690 }
3691 }
3692 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3693 return self->Disconnect(id, lastId, eventType,
3694 (wxObjectEventFunction)
3695 &wxPyCallback::EventThunker);
3696 }
3697 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3698 if (_self && _self != Py_None) {
3699 self->SetClientObject(new wxPyOORClientData(_self, incref));
3700 }
3701 else {
3702 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3703 if (data) {
3704 self->SetClientObject(NULL); // This will delete it too
3705 }
3706 }
3707 }
3708
3709 #if ! wxUSE_HOTKEY
3710 #define wxEVT_HOTKEY -9999
3711 #endif
3712
3713 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3714 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3715 if (data) {
3716 Py_INCREF(data->m_obj);
3717 return data->m_obj;
3718 } else {
3719 Py_INCREF(Py_None);
3720 return Py_None;
3721 }
3722 }
3723 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3724 wxPyClientData* data = new wxPyClientData(clientData);
3725 self->SetClientObject(data);
3726 }
3727 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3728 #if wxUSE_UNICODE
3729 return self->GetUnicodeKey();
3730 #else
3731 return 0;
3732 #endif
3733 }
3734 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3735 #if wxUSE_UNICODE
3736 self->m_uniChar = uniChar;
3737 #endif
3738 }
3739
3740 SWIGINTERNINLINE PyObject *
3741 SWIG_From_unsigned_SS_int (unsigned int value)
3742 {
3743 return SWIG_From_unsigned_SS_long (value);
3744 }
3745
3746
3747 SWIGINTERN int
3748 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3749 {
3750 unsigned long v;
3751 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3752 if (SWIG_IsOK(res)) {
3753 if ((v > UINT_MAX)) {
3754 return SWIG_OverflowError;
3755 } else {
3756 if (val) *val = static_cast< unsigned int >(v);
3757 }
3758 }
3759 return res;
3760 }
3761
3762 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3763 self->m_size = size;
3764 }
3765 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3766 int count = self->GetNumberOfFiles();
3767 wxString* files = self->GetFiles();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770
3771 if (!list) {
3772 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3773 wxPyEndBlockThreads(blocked);
3774 return NULL;
3775 }
3776
3777 for (int i=0; i<count; i++) {
3778 PyList_SetItem(list, i, wx2PyString(files[i]));
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return list;
3782 }
3783
3784
3785 SWIGINTERN wxPyApp *new_wxPyApp(){
3786 wxPythonApp = new wxPyApp();
3787 return wxPythonApp;
3788 }
3789 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3790 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3791 return wxPyTestDisplayAvailable();
3792 }
3793
3794 void wxApp_CleanUp() {
3795 __wxPyCleanup();
3796 }
3797
3798
3799 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3800
3801
3802
3803
3804
3805 SWIGINTERNINLINE PyObject *
3806 SWIG_FromCharPtr(const char *cptr)
3807 {
3808 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3809 }
3810
3811
3812 #if 0 // #ifdef __WXMAC__
3813
3814 // A dummy class that raises an exception if used...
3815 class wxEventLoop
3816 {
3817 public:
3818 wxEventLoop() { wxPyRaiseNotImplemented(); }
3819 int Run() { return 0; }
3820 void Exit(int rc = 0) {}
3821 bool Pending() const { return false; }
3822 bool Dispatch() { return false; }
3823 bool IsRunning() const { return false; }
3824 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3825 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3826 };
3827
3828 #else
3829
3830 #include <wx/evtloop.h>
3831
3832 #endif
3833
3834
3835
3836 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3837 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3838 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3839 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3840 wxWindowList& list = self->GetChildren();
3841 return wxPy_ConvertList(&list);
3842 }
3843 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3844 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3845 #if wxUSE_HOTKEY
3846 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3847 #else
3848 return false;
3849 #endif
3850 }
3851 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3852
3853
3854
3855 return false;
3856
3857 }
3858 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3859 return wxPyGetWinHandle(self);
3860 }
3861 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3862 self->AssociateHandle((WXWidget)handle);
3863 }
3864 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3865
3866 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3867 return wxWindow::FindWindowById(id, parent);
3868 }
3869
3870 wxWindow* wxFindWindowByName( const wxString& name,
3871 const wxWindow *parent = NULL ) {
3872 return wxWindow::FindWindowByName(name, parent);
3873 }
3874
3875 wxWindow* wxFindWindowByLabel( const wxString& label,
3876 const wxWindow *parent = NULL ) {
3877 return wxWindow::FindWindowByLabel(label, parent);
3878 }
3879
3880
3881 #ifdef __WXMSW__
3882 #include <wx/msw/private.h> // to get wxGetWindowId
3883 #endif
3884
3885
3886 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3887 #ifdef __WXMSW__
3888 WXHWND hWnd = (WXHWND)_hWnd;
3889 long id = wxGetWindowId(hWnd);
3890 wxWindow* win = new wxWindow;
3891 if (parent)
3892 parent->AddChild(win);
3893 win->SetEventHandler(win);
3894 win->SetHWND(hWnd);
3895 win->SetId(id);
3896 win->SubclassWin(hWnd);
3897 win->AdoptAttributesFromHWND();
3898 win->SetupColours();
3899 return win;
3900 #else
3901 wxPyRaiseNotImplemented();
3902 return NULL;
3903 #endif
3904 }
3905
3906
3907 PyObject* GetTopLevelWindows() {
3908 return wxPy_ConvertList(&wxTopLevelWindows);
3909 }
3910
3911
3912 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3913 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3914 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3915
3916 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3917
3918
3919 SWIGINTERNINLINE int
3920 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3921 {
3922 unsigned long v;
3923 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3924 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3925 return res;
3926 }
3927
3928 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3929 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3930 wxMenuItemList& list = self->GetMenuItems();
3931 return wxPy_ConvertList(&list);
3932 }
3933 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3934 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3935 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3936 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3937 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3938 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3939 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3940 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3941 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3942 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3943 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3944 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3945 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3946 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3947 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3948 static const wxString wxPyControlNameStr(wxControlNameStr);
3949 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3950 if (clientData) {
3951 wxPyClientData* data = new wxPyClientData(clientData);
3952 return self->Append(item, data);
3953 } else
3954 return self->Append(item);
3955 }
3956 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3957 if (clientData) {
3958 wxPyClientData* data = new wxPyClientData(clientData);
3959 return self->Insert(item, pos, data);
3960 } else
3961 return self->Insert(item, pos);
3962 }
3963 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3964 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3965 if (data) {
3966 Py_INCREF(data->m_obj);
3967 return data->m_obj;
3968 } else {
3969 Py_INCREF(Py_None);
3970 return Py_None;
3971 }
3972 }
3973 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3974 wxPyClientData* data = new wxPyClientData(clientData);
3975 self->SetClientObject(n, data);
3976 }
3977
3978
3979 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3980 wxPyUserData* data = NULL;
3981 if ( userData ) {
3982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3983 data = new wxPyUserData(userData);
3984 wxPyEndBlockThreads(blocked);
3985 }
3986 return new wxSizerItem(window, proportion, flag, border, data);
3987 }
3988 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3989 wxPyUserData* data = NULL;
3990 if ( userData ) {
3991 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3992 data = new wxPyUserData(userData);
3993 wxPyEndBlockThreads(blocked);
3994 }
3995 return new wxSizerItem(width, height, proportion, flag, border, data);
3996 }
3997 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3998 wxPyUserData* data = NULL;
3999 if ( userData ) {
4000 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4001 data = new wxPyUserData(userData);
4002 wxPyEndBlockThreads(blocked);
4003 }
4004 return new wxSizerItem(sizer, proportion, flag, border, data);
4005 }
4006
4007 SWIGINTERNINLINE PyObject *
4008 SWIG_From_float (float value)
4009 {
4010 return SWIG_From_double (value);
4011 }
4012
4013 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4014 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4015 if (data) {
4016 Py_INCREF(data->m_obj);
4017 return data->m_obj;
4018 } else {
4019 Py_INCREF(Py_None);
4020 return Py_None;
4021 }
4022 }
4023 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4024 wxPyUserData* data = NULL;
4025 if ( userData ) {
4026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4027 data = new wxPyUserData(userData);
4028 wxPyEndBlockThreads(blocked);
4029 }
4030 self->SetUserData(data);
4031 }
4032
4033 // Figure out the type of the sizer item
4034
4035 struct wxPySizerItemInfo {
4036 wxPySizerItemInfo()
4037 : window(NULL), sizer(NULL), gotSize(false),
4038 size(wxDefaultSize), gotPos(false), pos(-1)
4039 {}
4040
4041 wxWindow* window;
4042 wxSizer* sizer;
4043 bool gotSize;
4044 wxSize size;
4045 bool gotPos;
4046 int pos;
4047 };
4048
4049 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4050
4051 wxPySizerItemInfo info;
4052 wxSize size;
4053 wxSize* sizePtr = &size;
4054
4055 // Find out what the type of the item is
4056 // try wxWindow
4057 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4058 PyErr_Clear();
4059 info.window = NULL;
4060
4061 // try wxSizer
4062 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4063 PyErr_Clear();
4064 info.sizer = NULL;
4065
4066 // try wxSize or (w,h)
4067 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4068 info.size = *sizePtr;
4069 info.gotSize = true;
4070 }
4071
4072 // or a single int
4073 if (checkIdx && PyInt_Check(item)) {
4074 info.pos = PyInt_AsLong(item);
4075 info.gotPos = true;
4076 }
4077 }
4078 }
4079
4080 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4081 // no expected type, figure out what kind of error message to generate
4082 if ( !checkSize && !checkIdx )
4083 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4084 else if ( checkSize && !checkIdx )
4085 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4086 else if ( !checkSize && checkIdx)
4087 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4088 else
4089 // can this one happen?
4090 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4091 }
4092
4093 return info;
4094 }
4095
4096 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4097 if (!self->GetClientObject())
4098 self->SetClientObject(new wxPyOORClientData(_self));
4099 }
4100 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4101
4102 wxPyUserData* data = NULL;
4103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4104 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4105 if ( userData && (info.window || info.sizer || info.gotSize) )
4106 data = new wxPyUserData(userData);
4107 if ( info.sizer )
4108 PyObject_SetAttrString(item,"thisown",Py_False);
4109 wxPyEndBlockThreads(blocked);
4110
4111 // Now call the real Add method if a valid item type was found
4112 if ( info.window )
4113 return self->Add(info.window, proportion, flag, border, data);
4114 else if ( info.sizer )
4115 return self->Add(info.sizer, proportion, flag, border, data);
4116 else if (info.gotSize)
4117 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4118 proportion, flag, border, data);
4119 else
4120 return NULL;
4121 }
4122 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4123
4124 wxPyUserData* data = NULL;
4125 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4126 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4127 if ( userData && (info.window || info.sizer || info.gotSize) )
4128 data = new wxPyUserData(userData);
4129 if ( info.sizer )
4130 PyObject_SetAttrString(item,"thisown",Py_False);
4131 wxPyEndBlockThreads(blocked);
4132
4133 // Now call the real Insert method if a valid item type was found
4134 if ( info.window )
4135 return self->Insert(before, info.window, proportion, flag, border, data);
4136 else if ( info.sizer )
4137 return self->Insert(before, info.sizer, proportion, flag, border, data);
4138 else if (info.gotSize)
4139 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4140 proportion, flag, border, data);
4141 else
4142 return NULL;
4143 }
4144 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4145
4146 wxPyUserData* data = NULL;
4147 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4148 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4149 if ( userData && (info.window || info.sizer || info.gotSize) )
4150 data = new wxPyUserData(userData);
4151 if ( info.sizer )
4152 PyObject_SetAttrString(item,"thisown",Py_False);
4153 wxPyEndBlockThreads(blocked);
4154
4155 // Now call the real Prepend method if a valid item type was found
4156 if ( info.window )
4157 return self->Prepend(info.window, proportion, flag, border, data);
4158 else if ( info.sizer )
4159 return self->Prepend(info.sizer, proportion, flag, border, data);
4160 else if (info.gotSize)
4161 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4162 proportion, flag, border, data);
4163 else
4164 return NULL;
4165 }
4166 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4167 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4168 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4169 wxPyEndBlockThreads(blocked);
4170 if ( info.window )
4171 return self->Remove(info.window);
4172 else if ( info.sizer )
4173 return self->Remove(info.sizer);
4174 else if ( info.gotPos )
4175 return self->Remove(info.pos);
4176 else
4177 return false;
4178 }
4179 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4181 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4182 wxPyEndBlockThreads(blocked);
4183 if ( info.window )
4184 return self->Detach(info.window);
4185 else if ( info.sizer )
4186 return self->Detach(info.sizer);
4187 else if ( info.gotPos )
4188 return self->Detach(info.pos);
4189 else
4190 return false;
4191 }
4192 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4193 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4194 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4195 wxPyEndBlockThreads(blocked);
4196 if ( info.window )
4197 return self->GetItem(info.window);
4198 else if ( info.sizer )
4199 return self->GetItem(info.sizer);
4200 else if ( info.gotPos )
4201 return self->GetItem(info.pos);
4202 else
4203 return NULL;
4204 }
4205 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4206 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4207 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4208 wxPyEndBlockThreads(blocked);
4209 if ( info.window )
4210 self->SetItemMinSize(info.window, size);
4211 else if ( info.sizer )
4212 self->SetItemMinSize(info.sizer, size);
4213 else if ( info.gotPos )
4214 self->SetItemMinSize(info.pos, size);
4215 }
4216 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4217 wxSizerItemList& list = self->GetChildren();
4218 return wxPy_ConvertList(&list);
4219 }
4220 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4222 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4223 wxPyEndBlockThreads(blocked);
4224 if ( info.window )
4225 return self->Show(info.window, show, recursive);
4226 else if ( info.sizer )
4227 return self->Show(info.sizer, show, recursive);
4228 else if ( info.gotPos )
4229 return self->Show(info.pos, show);
4230 else
4231 return false;
4232 }
4233 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4234 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4235 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4236 wxPyEndBlockThreads(blocked);
4237 if ( info.window )
4238 return self->IsShown(info.window);
4239 else if ( info.sizer )
4240 return self->IsShown(info.sizer);
4241 else if ( info.gotPos )
4242 return self->IsShown(info.pos);
4243 else
4244 return false;
4245 }
4246
4247 // See pyclasses.h
4248 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4249 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4250 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4251
4252
4253
4254
4255 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4256 {
4257 if (source == Py_None) {
4258 **obj = wxGBPosition(-1,-1);
4259 return true;
4260 }
4261 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4262 }
4263
4264 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4265 {
4266 if (source == Py_None) {
4267 **obj = wxGBSpan(-1,-1);
4268 return true;
4269 }
4270 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4271 }
4272
4273
4274 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4275 wxGBPosition temp, *obj = &temp;
4276 if ( other == Py_None ) return false;
4277 if ( ! wxGBPosition_helper(other, &obj) ) {
4278 PyErr_Clear();
4279 return false;
4280 }
4281 return self->operator==(*obj);
4282 }
4283 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4284 wxGBPosition temp, *obj = &temp;
4285 if ( other == Py_None ) return true;
4286 if ( ! wxGBPosition_helper(other, &obj)) {
4287 PyErr_Clear();
4288 return true;
4289 }
4290 return self->operator!=(*obj);
4291 }
4292 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4293 self->SetRow(row);
4294 self->SetCol(col);
4295 }
4296 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4297 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4298 PyObject* tup = PyTuple_New(2);
4299 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4300 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4301 wxPyEndBlockThreads(blocked);
4302 return tup;
4303 }
4304 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4305 wxGBSpan temp, *obj = &temp;
4306 if ( other == Py_None ) return false;
4307 if ( ! wxGBSpan_helper(other, &obj) ) {
4308 PyErr_Clear();
4309 return false;
4310 }
4311 return self->operator==(*obj);
4312 }
4313 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4314 wxGBSpan temp, *obj = &temp;
4315 if ( other == Py_None ) return true;
4316 if ( ! wxGBSpan_helper(other, &obj)) {
4317 PyErr_Clear();
4318 return true;
4319 }
4320 return self->operator!=(*obj);
4321 }
4322 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4323 self->SetRowspan(rowspan);
4324 self->SetColspan(colspan);
4325 }
4326 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4327 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4328 PyObject* tup = PyTuple_New(2);
4329 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4330 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4331 wxPyEndBlockThreads(blocked);
4332 return tup;
4333 }
4334 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4335 wxPyUserData* data = NULL;
4336 if ( userData ) {
4337 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4338 data = new wxPyUserData(userData);
4339 wxPyEndBlockThreads(blocked);
4340 }
4341 return new wxGBSizerItem(window, pos, span, flag, border, data);
4342 }
4343 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4344 wxPyUserData* data = NULL;
4345 if ( userData ) {
4346 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4347 data = new wxPyUserData(userData);
4348 wxPyEndBlockThreads(blocked);
4349 }
4350 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4351 }
4352 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4353 wxPyUserData* data = NULL;
4354 if ( userData ) {
4355 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4356 data = new wxPyUserData(userData);
4357 wxPyEndBlockThreads(blocked);
4358 }
4359 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4360 }
4361 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4362 int row, col;
4363 self->GetEndPos(row, col);
4364 return wxGBPosition(row, col);
4365 }
4366 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4367
4368 wxPyUserData* data = NULL;
4369 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4370 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4371 if ( userData && (info.window || info.sizer || info.gotSize) )
4372 data = new wxPyUserData(userData);
4373 if ( info.sizer )
4374 PyObject_SetAttrString(item,"thisown",Py_False);
4375 wxPyEndBlockThreads(blocked);
4376
4377 // Now call the real Add method if a valid item type was found
4378 if ( info.window )
4379 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4380 else if ( info.sizer )
4381 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4382 else if (info.gotSize)
4383 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4384 pos, span, flag, border, data);
4385 return NULL;
4386 }
4387
4388
4389 #ifdef __cplusplus
4390 extern "C" {
4391 #endif
4392 SWIGINTERN int EmptyString_set(PyObject *) {
4393 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4394 return 1;
4395 }
4396
4397
4398 SWIGINTERN PyObject *EmptyString_get(void) {
4399 PyObject *pyobj = 0;
4400
4401 {
4402 #if wxUSE_UNICODE
4403 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4404 #else
4405 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4406 #endif
4407 }
4408 return pyobj;
4409 }
4410
4411
4412 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4413 PyObject *resultobj = 0;
4414 wxObject *arg1 = (wxObject *) 0 ;
4415 wxString result;
4416 void *argp1 = 0 ;
4417 int res1 = 0 ;
4418 PyObject *swig_obj[1] ;
4419
4420 if (!args) SWIG_fail;
4421 swig_obj[0] = args;
4422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4423 if (!SWIG_IsOK(res1)) {
4424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4425 }
4426 arg1 = reinterpret_cast< wxObject * >(argp1);
4427 {
4428 PyThreadState* __tstate = wxPyBeginAllowThreads();
4429 result = wxObject_GetClassName(arg1);
4430 wxPyEndAllowThreads(__tstate);
4431 if (PyErr_Occurred()) SWIG_fail;
4432 }
4433 {
4434 #if wxUSE_UNICODE
4435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4436 #else
4437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4438 #endif
4439 }
4440 return resultobj;
4441 fail:
4442 return NULL;
4443 }
4444
4445
4446 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4447 PyObject *resultobj = 0;
4448 wxObject *arg1 = (wxObject *) 0 ;
4449 void *argp1 = 0 ;
4450 int res1 = 0 ;
4451 PyObject *swig_obj[1] ;
4452
4453 if (!args) SWIG_fail;
4454 swig_obj[0] = args;
4455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4456 if (!SWIG_IsOK(res1)) {
4457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4458 }
4459 arg1 = reinterpret_cast< wxObject * >(argp1);
4460 {
4461 PyThreadState* __tstate = wxPyBeginAllowThreads();
4462 wxObject_Destroy(arg1);
4463 wxPyEndAllowThreads(__tstate);
4464 if (PyErr_Occurred()) SWIG_fail;
4465 }
4466 resultobj = SWIG_Py_Void();
4467 return resultobj;
4468 fail:
4469 return NULL;
4470 }
4471
4472
4473 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4474 PyObject *obj;
4475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4476 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4477 return SWIG_Py_Void();
4478 }
4479
4480 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4481 PyObject *resultobj = 0;
4482 wxSize *arg1 = (wxSize *) 0 ;
4483 int arg2 ;
4484 void *argp1 = 0 ;
4485 int res1 = 0 ;
4486 int val2 ;
4487 int ecode2 = 0 ;
4488 PyObject *swig_obj[2] ;
4489
4490 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4492 if (!SWIG_IsOK(res1)) {
4493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4494 }
4495 arg1 = reinterpret_cast< wxSize * >(argp1);
4496 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4497 if (!SWIG_IsOK(ecode2)) {
4498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4499 }
4500 arg2 = static_cast< int >(val2);
4501 if (arg1) (arg1)->x = arg2;
4502
4503 resultobj = SWIG_Py_Void();
4504 return resultobj;
4505 fail:
4506 return NULL;
4507 }
4508
4509
4510 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4511 PyObject *resultobj = 0;
4512 wxSize *arg1 = (wxSize *) 0 ;
4513 int result;
4514 void *argp1 = 0 ;
4515 int res1 = 0 ;
4516 PyObject *swig_obj[1] ;
4517
4518 if (!args) SWIG_fail;
4519 swig_obj[0] = args;
4520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4521 if (!SWIG_IsOK(res1)) {
4522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4523 }
4524 arg1 = reinterpret_cast< wxSize * >(argp1);
4525 result = (int) ((arg1)->x);
4526 resultobj = SWIG_From_int(static_cast< int >(result));
4527 return resultobj;
4528 fail:
4529 return NULL;
4530 }
4531
4532
4533 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4534 PyObject *resultobj = 0;
4535 wxSize *arg1 = (wxSize *) 0 ;
4536 int arg2 ;
4537 void *argp1 = 0 ;
4538 int res1 = 0 ;
4539 int val2 ;
4540 int ecode2 = 0 ;
4541 PyObject *swig_obj[2] ;
4542
4543 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4545 if (!SWIG_IsOK(res1)) {
4546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4547 }
4548 arg1 = reinterpret_cast< wxSize * >(argp1);
4549 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4550 if (!SWIG_IsOK(ecode2)) {
4551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4552 }
4553 arg2 = static_cast< int >(val2);
4554 if (arg1) (arg1)->y = arg2;
4555
4556 resultobj = SWIG_Py_Void();
4557 return resultobj;
4558 fail:
4559 return NULL;
4560 }
4561
4562
4563 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4564 PyObject *resultobj = 0;
4565 wxSize *arg1 = (wxSize *) 0 ;
4566 int result;
4567 void *argp1 = 0 ;
4568 int res1 = 0 ;
4569 PyObject *swig_obj[1] ;
4570
4571 if (!args) SWIG_fail;
4572 swig_obj[0] = args;
4573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4574 if (!SWIG_IsOK(res1)) {
4575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4576 }
4577 arg1 = reinterpret_cast< wxSize * >(argp1);
4578 result = (int) ((arg1)->y);
4579 resultobj = SWIG_From_int(static_cast< int >(result));
4580 return resultobj;
4581 fail:
4582 return NULL;
4583 }
4584
4585
4586 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4587 PyObject *resultobj = 0;
4588 int arg1 = (int) 0 ;
4589 int arg2 = (int) 0 ;
4590 wxSize *result = 0 ;
4591 int val1 ;
4592 int ecode1 = 0 ;
4593 int val2 ;
4594 int ecode2 = 0 ;
4595 PyObject * obj0 = 0 ;
4596 PyObject * obj1 = 0 ;
4597 char * kwnames[] = {
4598 (char *) "w",(char *) "h", NULL
4599 };
4600
4601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4602 if (obj0) {
4603 ecode1 = SWIG_AsVal_int(obj0, &val1);
4604 if (!SWIG_IsOK(ecode1)) {
4605 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4606 }
4607 arg1 = static_cast< int >(val1);
4608 }
4609 if (obj1) {
4610 ecode2 = SWIG_AsVal_int(obj1, &val2);
4611 if (!SWIG_IsOK(ecode2)) {
4612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4613 }
4614 arg2 = static_cast< int >(val2);
4615 }
4616 {
4617 PyThreadState* __tstate = wxPyBeginAllowThreads();
4618 result = (wxSize *)new wxSize(arg1,arg2);
4619 wxPyEndAllowThreads(__tstate);
4620 if (PyErr_Occurred()) SWIG_fail;
4621 }
4622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4623 return resultobj;
4624 fail:
4625 return NULL;
4626 }
4627
4628
4629 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4630 PyObject *resultobj = 0;
4631 wxSize *arg1 = (wxSize *) 0 ;
4632 void *argp1 = 0 ;
4633 int res1 = 0 ;
4634 PyObject *swig_obj[1] ;
4635
4636 if (!args) SWIG_fail;
4637 swig_obj[0] = args;
4638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4639 if (!SWIG_IsOK(res1)) {
4640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4641 }
4642 arg1 = reinterpret_cast< wxSize * >(argp1);
4643 {
4644 PyThreadState* __tstate = wxPyBeginAllowThreads();
4645 delete arg1;
4646
4647 wxPyEndAllowThreads(__tstate);
4648 if (PyErr_Occurred()) SWIG_fail;
4649 }
4650 resultobj = SWIG_Py_Void();
4651 return resultobj;
4652 fail:
4653 return NULL;
4654 }
4655
4656
4657 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4658 PyObject *resultobj = 0;
4659 wxSize *arg1 = (wxSize *) 0 ;
4660 PyObject *arg2 = (PyObject *) 0 ;
4661 bool result;
4662 void *argp1 = 0 ;
4663 int res1 = 0 ;
4664 PyObject * obj0 = 0 ;
4665 PyObject * obj1 = 0 ;
4666 char * kwnames[] = {
4667 (char *) "self",(char *) "other", NULL
4668 };
4669
4670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4672 if (!SWIG_IsOK(res1)) {
4673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4674 }
4675 arg1 = reinterpret_cast< wxSize * >(argp1);
4676 arg2 = obj1;
4677 {
4678 result = (bool)wxSize___eq__(arg1,arg2);
4679 if (PyErr_Occurred()) SWIG_fail;
4680 }
4681 {
4682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4683 }
4684 return resultobj;
4685 fail:
4686 return NULL;
4687 }
4688
4689
4690 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4691 PyObject *resultobj = 0;
4692 wxSize *arg1 = (wxSize *) 0 ;
4693 PyObject *arg2 = (PyObject *) 0 ;
4694 bool result;
4695 void *argp1 = 0 ;
4696 int res1 = 0 ;
4697 PyObject * obj0 = 0 ;
4698 PyObject * obj1 = 0 ;
4699 char * kwnames[] = {
4700 (char *) "self",(char *) "other", NULL
4701 };
4702
4703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4705 if (!SWIG_IsOK(res1)) {
4706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4707 }
4708 arg1 = reinterpret_cast< wxSize * >(argp1);
4709 arg2 = obj1;
4710 {
4711 result = (bool)wxSize___ne__(arg1,arg2);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 {
4715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4716 }
4717 return resultobj;
4718 fail:
4719 return NULL;
4720 }
4721
4722
4723 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4724 PyObject *resultobj = 0;
4725 wxSize *arg1 = (wxSize *) 0 ;
4726 wxSize *arg2 = 0 ;
4727 wxSize result;
4728 void *argp1 = 0 ;
4729 int res1 = 0 ;
4730 wxSize temp2 ;
4731 PyObject * obj0 = 0 ;
4732 PyObject * obj1 = 0 ;
4733 char * kwnames[] = {
4734 (char *) "self",(char *) "sz", NULL
4735 };
4736
4737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4739 if (!SWIG_IsOK(res1)) {
4740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4741 }
4742 arg1 = reinterpret_cast< wxSize * >(argp1);
4743 {
4744 arg2 = &temp2;
4745 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4746 }
4747 {
4748 PyThreadState* __tstate = wxPyBeginAllowThreads();
4749 result = (arg1)->operator +((wxSize const &)*arg2);
4750 wxPyEndAllowThreads(__tstate);
4751 if (PyErr_Occurred()) SWIG_fail;
4752 }
4753 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4754 return resultobj;
4755 fail:
4756 return NULL;
4757 }
4758
4759
4760 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4761 PyObject *resultobj = 0;
4762 wxSize *arg1 = (wxSize *) 0 ;
4763 wxSize *arg2 = 0 ;
4764 wxSize result;
4765 void *argp1 = 0 ;
4766 int res1 = 0 ;
4767 wxSize temp2 ;
4768 PyObject * obj0 = 0 ;
4769 PyObject * obj1 = 0 ;
4770 char * kwnames[] = {
4771 (char *) "self",(char *) "sz", NULL
4772 };
4773
4774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4776 if (!SWIG_IsOK(res1)) {
4777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4778 }
4779 arg1 = reinterpret_cast< wxSize * >(argp1);
4780 {
4781 arg2 = &temp2;
4782 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4783 }
4784 {
4785 PyThreadState* __tstate = wxPyBeginAllowThreads();
4786 result = (arg1)->operator -((wxSize const &)*arg2);
4787 wxPyEndAllowThreads(__tstate);
4788 if (PyErr_Occurred()) SWIG_fail;
4789 }
4790 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4791 return resultobj;
4792 fail:
4793 return NULL;
4794 }
4795
4796
4797 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4798 PyObject *resultobj = 0;
4799 wxSize *arg1 = (wxSize *) 0 ;
4800 wxSize *arg2 = 0 ;
4801 void *argp1 = 0 ;
4802 int res1 = 0 ;
4803 wxSize temp2 ;
4804 PyObject * obj0 = 0 ;
4805 PyObject * obj1 = 0 ;
4806 char * kwnames[] = {
4807 (char *) "self",(char *) "sz", NULL
4808 };
4809
4810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4812 if (!SWIG_IsOK(res1)) {
4813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4814 }
4815 arg1 = reinterpret_cast< wxSize * >(argp1);
4816 {
4817 arg2 = &temp2;
4818 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4819 }
4820 {
4821 PyThreadState* __tstate = wxPyBeginAllowThreads();
4822 (arg1)->IncTo((wxSize const &)*arg2);
4823 wxPyEndAllowThreads(__tstate);
4824 if (PyErr_Occurred()) SWIG_fail;
4825 }
4826 resultobj = SWIG_Py_Void();
4827 return resultobj;
4828 fail:
4829 return NULL;
4830 }
4831
4832
4833 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4834 PyObject *resultobj = 0;
4835 wxSize *arg1 = (wxSize *) 0 ;
4836 wxSize *arg2 = 0 ;
4837 void *argp1 = 0 ;
4838 int res1 = 0 ;
4839 wxSize temp2 ;
4840 PyObject * obj0 = 0 ;
4841 PyObject * obj1 = 0 ;
4842 char * kwnames[] = {
4843 (char *) "self",(char *) "sz", NULL
4844 };
4845
4846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4848 if (!SWIG_IsOK(res1)) {
4849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4850 }
4851 arg1 = reinterpret_cast< wxSize * >(argp1);
4852 {
4853 arg2 = &temp2;
4854 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4855 }
4856 {
4857 PyThreadState* __tstate = wxPyBeginAllowThreads();
4858 (arg1)->DecTo((wxSize const &)*arg2);
4859 wxPyEndAllowThreads(__tstate);
4860 if (PyErr_Occurred()) SWIG_fail;
4861 }
4862 resultobj = SWIG_Py_Void();
4863 return resultobj;
4864 fail:
4865 return NULL;
4866 }
4867
4868
4869 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4870 PyObject *resultobj = 0;
4871 wxSize *arg1 = (wxSize *) 0 ;
4872 float arg2 ;
4873 float arg3 ;
4874 void *argp1 = 0 ;
4875 int res1 = 0 ;
4876 float val2 ;
4877 int ecode2 = 0 ;
4878 float val3 ;
4879 int ecode3 = 0 ;
4880 PyObject * obj0 = 0 ;
4881 PyObject * obj1 = 0 ;
4882 PyObject * obj2 = 0 ;
4883 char * kwnames[] = {
4884 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4885 };
4886
4887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4889 if (!SWIG_IsOK(res1)) {
4890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4891 }
4892 arg1 = reinterpret_cast< wxSize * >(argp1);
4893 ecode2 = SWIG_AsVal_float(obj1, &val2);
4894 if (!SWIG_IsOK(ecode2)) {
4895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4896 }
4897 arg2 = static_cast< float >(val2);
4898 ecode3 = SWIG_AsVal_float(obj2, &val3);
4899 if (!SWIG_IsOK(ecode3)) {
4900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4901 }
4902 arg3 = static_cast< float >(val3);
4903 {
4904 PyThreadState* __tstate = wxPyBeginAllowThreads();
4905 (arg1)->Scale(arg2,arg3);
4906 wxPyEndAllowThreads(__tstate);
4907 if (PyErr_Occurred()) SWIG_fail;
4908 }
4909 resultobj = SWIG_Py_Void();
4910 return resultobj;
4911 fail:
4912 return NULL;
4913 }
4914
4915
4916 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4917 PyObject *resultobj = 0;
4918 wxSize *arg1 = (wxSize *) 0 ;
4919 int arg2 ;
4920 int arg3 ;
4921 void *argp1 = 0 ;
4922 int res1 = 0 ;
4923 int val2 ;
4924 int ecode2 = 0 ;
4925 int val3 ;
4926 int ecode3 = 0 ;
4927 PyObject * obj0 = 0 ;
4928 PyObject * obj1 = 0 ;
4929 PyObject * obj2 = 0 ;
4930 char * kwnames[] = {
4931 (char *) "self",(char *) "w",(char *) "h", NULL
4932 };
4933
4934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4936 if (!SWIG_IsOK(res1)) {
4937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4938 }
4939 arg1 = reinterpret_cast< wxSize * >(argp1);
4940 ecode2 = SWIG_AsVal_int(obj1, &val2);
4941 if (!SWIG_IsOK(ecode2)) {
4942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4943 }
4944 arg2 = static_cast< int >(val2);
4945 ecode3 = SWIG_AsVal_int(obj2, &val3);
4946 if (!SWIG_IsOK(ecode3)) {
4947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4948 }
4949 arg3 = static_cast< int >(val3);
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 (arg1)->Set(arg2,arg3);
4953 wxPyEndAllowThreads(__tstate);
4954 if (PyErr_Occurred()) SWIG_fail;
4955 }
4956 resultobj = SWIG_Py_Void();
4957 return resultobj;
4958 fail:
4959 return NULL;
4960 }
4961
4962
4963 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4964 PyObject *resultobj = 0;
4965 wxSize *arg1 = (wxSize *) 0 ;
4966 int arg2 ;
4967 void *argp1 = 0 ;
4968 int res1 = 0 ;
4969 int val2 ;
4970 int ecode2 = 0 ;
4971 PyObject * obj0 = 0 ;
4972 PyObject * obj1 = 0 ;
4973 char * kwnames[] = {
4974 (char *) "self",(char *) "w", NULL
4975 };
4976
4977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4979 if (!SWIG_IsOK(res1)) {
4980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4981 }
4982 arg1 = reinterpret_cast< wxSize * >(argp1);
4983 ecode2 = SWIG_AsVal_int(obj1, &val2);
4984 if (!SWIG_IsOK(ecode2)) {
4985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4986 }
4987 arg2 = static_cast< int >(val2);
4988 {
4989 PyThreadState* __tstate = wxPyBeginAllowThreads();
4990 (arg1)->SetWidth(arg2);
4991 wxPyEndAllowThreads(__tstate);
4992 if (PyErr_Occurred()) SWIG_fail;
4993 }
4994 resultobj = SWIG_Py_Void();
4995 return resultobj;
4996 fail:
4997 return NULL;
4998 }
4999
5000
5001 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5002 PyObject *resultobj = 0;
5003 wxSize *arg1 = (wxSize *) 0 ;
5004 int arg2 ;
5005 void *argp1 = 0 ;
5006 int res1 = 0 ;
5007 int val2 ;
5008 int ecode2 = 0 ;
5009 PyObject * obj0 = 0 ;
5010 PyObject * obj1 = 0 ;
5011 char * kwnames[] = {
5012 (char *) "self",(char *) "h", NULL
5013 };
5014
5015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5017 if (!SWIG_IsOK(res1)) {
5018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5019 }
5020 arg1 = reinterpret_cast< wxSize * >(argp1);
5021 ecode2 = SWIG_AsVal_int(obj1, &val2);
5022 if (!SWIG_IsOK(ecode2)) {
5023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5024 }
5025 arg2 = static_cast< int >(val2);
5026 {
5027 PyThreadState* __tstate = wxPyBeginAllowThreads();
5028 (arg1)->SetHeight(arg2);
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 resultobj = SWIG_Py_Void();
5033 return resultobj;
5034 fail:
5035 return NULL;
5036 }
5037
5038
5039 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5040 PyObject *resultobj = 0;
5041 wxSize *arg1 = (wxSize *) 0 ;
5042 int result;
5043 void *argp1 = 0 ;
5044 int res1 = 0 ;
5045 PyObject *swig_obj[1] ;
5046
5047 if (!args) SWIG_fail;
5048 swig_obj[0] = args;
5049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5050 if (!SWIG_IsOK(res1)) {
5051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5052 }
5053 arg1 = reinterpret_cast< wxSize * >(argp1);
5054 {
5055 PyThreadState* __tstate = wxPyBeginAllowThreads();
5056 result = (int)((wxSize const *)arg1)->GetWidth();
5057 wxPyEndAllowThreads(__tstate);
5058 if (PyErr_Occurred()) SWIG_fail;
5059 }
5060 resultobj = SWIG_From_int(static_cast< int >(result));
5061 return resultobj;
5062 fail:
5063 return NULL;
5064 }
5065
5066
5067 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5068 PyObject *resultobj = 0;
5069 wxSize *arg1 = (wxSize *) 0 ;
5070 int result;
5071 void *argp1 = 0 ;
5072 int res1 = 0 ;
5073 PyObject *swig_obj[1] ;
5074
5075 if (!args) SWIG_fail;
5076 swig_obj[0] = args;
5077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5078 if (!SWIG_IsOK(res1)) {
5079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5080 }
5081 arg1 = reinterpret_cast< wxSize * >(argp1);
5082 {
5083 PyThreadState* __tstate = wxPyBeginAllowThreads();
5084 result = (int)((wxSize const *)arg1)->GetHeight();
5085 wxPyEndAllowThreads(__tstate);
5086 if (PyErr_Occurred()) SWIG_fail;
5087 }
5088 resultobj = SWIG_From_int(static_cast< int >(result));
5089 return resultobj;
5090 fail:
5091 return NULL;
5092 }
5093
5094
5095 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5096 PyObject *resultobj = 0;
5097 wxSize *arg1 = (wxSize *) 0 ;
5098 bool result;
5099 void *argp1 = 0 ;
5100 int res1 = 0 ;
5101 PyObject *swig_obj[1] ;
5102
5103 if (!args) SWIG_fail;
5104 swig_obj[0] = args;
5105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5106 if (!SWIG_IsOK(res1)) {
5107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5108 }
5109 arg1 = reinterpret_cast< wxSize * >(argp1);
5110 {
5111 PyThreadState* __tstate = wxPyBeginAllowThreads();
5112 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5113 wxPyEndAllowThreads(__tstate);
5114 if (PyErr_Occurred()) SWIG_fail;
5115 }
5116 {
5117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5118 }
5119 return resultobj;
5120 fail:
5121 return NULL;
5122 }
5123
5124
5125 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5126 PyObject *resultobj = 0;
5127 wxSize *arg1 = (wxSize *) 0 ;
5128 wxSize *arg2 = 0 ;
5129 void *argp1 = 0 ;
5130 int res1 = 0 ;
5131 wxSize temp2 ;
5132 PyObject * obj0 = 0 ;
5133 PyObject * obj1 = 0 ;
5134 char * kwnames[] = {
5135 (char *) "self",(char *) "size", NULL
5136 };
5137
5138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5140 if (!SWIG_IsOK(res1)) {
5141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5142 }
5143 arg1 = reinterpret_cast< wxSize * >(argp1);
5144 {
5145 arg2 = &temp2;
5146 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5147 }
5148 {
5149 PyThreadState* __tstate = wxPyBeginAllowThreads();
5150 (arg1)->SetDefaults((wxSize const &)*arg2);
5151 wxPyEndAllowThreads(__tstate);
5152 if (PyErr_Occurred()) SWIG_fail;
5153 }
5154 resultobj = SWIG_Py_Void();
5155 return resultobj;
5156 fail:
5157 return NULL;
5158 }
5159
5160
5161 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5162 PyObject *resultobj = 0;
5163 wxSize *arg1 = (wxSize *) 0 ;
5164 PyObject *result = 0 ;
5165 void *argp1 = 0 ;
5166 int res1 = 0 ;
5167 PyObject *swig_obj[1] ;
5168
5169 if (!args) SWIG_fail;
5170 swig_obj[0] = args;
5171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5172 if (!SWIG_IsOK(res1)) {
5173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5174 }
5175 arg1 = reinterpret_cast< wxSize * >(argp1);
5176 {
5177 PyThreadState* __tstate = wxPyBeginAllowThreads();
5178 result = (PyObject *)wxSize_Get(arg1);
5179 wxPyEndAllowThreads(__tstate);
5180 if (PyErr_Occurred()) SWIG_fail;
5181 }
5182 resultobj = result;
5183 return resultobj;
5184 fail:
5185 return NULL;
5186 }
5187
5188
5189 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5190 PyObject *obj;
5191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5192 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5193 return SWIG_Py_Void();
5194 }
5195
5196 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5197 return SWIG_Python_InitShadowInstance(args);
5198 }
5199
5200 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5201 PyObject *resultobj = 0;
5202 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5203 double arg2 ;
5204 void *argp1 = 0 ;
5205 int res1 = 0 ;
5206 double val2 ;
5207 int ecode2 = 0 ;
5208 PyObject *swig_obj[2] ;
5209
5210 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5212 if (!SWIG_IsOK(res1)) {
5213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5214 }
5215 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5216 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5217 if (!SWIG_IsOK(ecode2)) {
5218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5219 }
5220 arg2 = static_cast< double >(val2);
5221 if (arg1) (arg1)->x = arg2;
5222
5223 resultobj = SWIG_Py_Void();
5224 return resultobj;
5225 fail:
5226 return NULL;
5227 }
5228
5229
5230 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5231 PyObject *resultobj = 0;
5232 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5233 double result;
5234 void *argp1 = 0 ;
5235 int res1 = 0 ;
5236 PyObject *swig_obj[1] ;
5237
5238 if (!args) SWIG_fail;
5239 swig_obj[0] = args;
5240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5241 if (!SWIG_IsOK(res1)) {
5242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5243 }
5244 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5245 result = (double) ((arg1)->x);
5246 resultobj = SWIG_From_double(static_cast< double >(result));
5247 return resultobj;
5248 fail:
5249 return NULL;
5250 }
5251
5252
5253 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5254 PyObject *resultobj = 0;
5255 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5256 double arg2 ;
5257 void *argp1 = 0 ;
5258 int res1 = 0 ;
5259 double val2 ;
5260 int ecode2 = 0 ;
5261 PyObject *swig_obj[2] ;
5262
5263 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5265 if (!SWIG_IsOK(res1)) {
5266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5267 }
5268 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5269 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5270 if (!SWIG_IsOK(ecode2)) {
5271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5272 }
5273 arg2 = static_cast< double >(val2);
5274 if (arg1) (arg1)->y = arg2;
5275
5276 resultobj = SWIG_Py_Void();
5277 return resultobj;
5278 fail:
5279 return NULL;
5280 }
5281
5282
5283 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5284 PyObject *resultobj = 0;
5285 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5286 double result;
5287 void *argp1 = 0 ;
5288 int res1 = 0 ;
5289 PyObject *swig_obj[1] ;
5290
5291 if (!args) SWIG_fail;
5292 swig_obj[0] = args;
5293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5294 if (!SWIG_IsOK(res1)) {
5295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5296 }
5297 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5298 result = (double) ((arg1)->y);
5299 resultobj = SWIG_From_double(static_cast< double >(result));
5300 return resultobj;
5301 fail:
5302 return NULL;
5303 }
5304
5305
5306 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5307 PyObject *resultobj = 0;
5308 double arg1 = (double) 0.0 ;
5309 double arg2 = (double) 0.0 ;
5310 wxRealPoint *result = 0 ;
5311 double val1 ;
5312 int ecode1 = 0 ;
5313 double val2 ;
5314 int ecode2 = 0 ;
5315 PyObject * obj0 = 0 ;
5316 PyObject * obj1 = 0 ;
5317 char * kwnames[] = {
5318 (char *) "x",(char *) "y", NULL
5319 };
5320
5321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5322 if (obj0) {
5323 ecode1 = SWIG_AsVal_double(obj0, &val1);
5324 if (!SWIG_IsOK(ecode1)) {
5325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5326 }
5327 arg1 = static_cast< double >(val1);
5328 }
5329 if (obj1) {
5330 ecode2 = SWIG_AsVal_double(obj1, &val2);
5331 if (!SWIG_IsOK(ecode2)) {
5332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5333 }
5334 arg2 = static_cast< double >(val2);
5335 }
5336 {
5337 PyThreadState* __tstate = wxPyBeginAllowThreads();
5338 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5339 wxPyEndAllowThreads(__tstate);
5340 if (PyErr_Occurred()) SWIG_fail;
5341 }
5342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5343 return resultobj;
5344 fail:
5345 return NULL;
5346 }
5347
5348
5349 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5350 PyObject *resultobj = 0;
5351 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5352 void *argp1 = 0 ;
5353 int res1 = 0 ;
5354 PyObject *swig_obj[1] ;
5355
5356 if (!args) SWIG_fail;
5357 swig_obj[0] = args;
5358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5359 if (!SWIG_IsOK(res1)) {
5360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5361 }
5362 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5363 {
5364 PyThreadState* __tstate = wxPyBeginAllowThreads();
5365 delete arg1;
5366
5367 wxPyEndAllowThreads(__tstate);
5368 if (PyErr_Occurred()) SWIG_fail;
5369 }
5370 resultobj = SWIG_Py_Void();
5371 return resultobj;
5372 fail:
5373 return NULL;
5374 }
5375
5376
5377 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5378 PyObject *resultobj = 0;
5379 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5380 PyObject *arg2 = (PyObject *) 0 ;
5381 bool result;
5382 void *argp1 = 0 ;
5383 int res1 = 0 ;
5384 PyObject * obj0 = 0 ;
5385 PyObject * obj1 = 0 ;
5386 char * kwnames[] = {
5387 (char *) "self",(char *) "other", NULL
5388 };
5389
5390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5392 if (!SWIG_IsOK(res1)) {
5393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5394 }
5395 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5396 arg2 = obj1;
5397 {
5398 result = (bool)wxRealPoint___eq__(arg1,arg2);
5399 if (PyErr_Occurred()) SWIG_fail;
5400 }
5401 {
5402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5403 }
5404 return resultobj;
5405 fail:
5406 return NULL;
5407 }
5408
5409
5410 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5411 PyObject *resultobj = 0;
5412 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5413 PyObject *arg2 = (PyObject *) 0 ;
5414 bool result;
5415 void *argp1 = 0 ;
5416 int res1 = 0 ;
5417 PyObject * obj0 = 0 ;
5418 PyObject * obj1 = 0 ;
5419 char * kwnames[] = {
5420 (char *) "self",(char *) "other", NULL
5421 };
5422
5423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5425 if (!SWIG_IsOK(res1)) {
5426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5427 }
5428 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5429 arg2 = obj1;
5430 {
5431 result = (bool)wxRealPoint___ne__(arg1,arg2);
5432 if (PyErr_Occurred()) SWIG_fail;
5433 }
5434 {
5435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5436 }
5437 return resultobj;
5438 fail:
5439 return NULL;
5440 }
5441
5442
5443 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5444 PyObject *resultobj = 0;
5445 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5446 wxRealPoint *arg2 = 0 ;
5447 wxRealPoint result;
5448 void *argp1 = 0 ;
5449 int res1 = 0 ;
5450 wxRealPoint temp2 ;
5451 PyObject * obj0 = 0 ;
5452 PyObject * obj1 = 0 ;
5453 char * kwnames[] = {
5454 (char *) "self",(char *) "pt", NULL
5455 };
5456
5457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5459 if (!SWIG_IsOK(res1)) {
5460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5461 }
5462 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5463 {
5464 arg2 = &temp2;
5465 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5466 }
5467 {
5468 PyThreadState* __tstate = wxPyBeginAllowThreads();
5469 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5470 wxPyEndAllowThreads(__tstate);
5471 if (PyErr_Occurred()) SWIG_fail;
5472 }
5473 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5481 PyObject *resultobj = 0;
5482 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5483 wxRealPoint *arg2 = 0 ;
5484 wxRealPoint result;
5485 void *argp1 = 0 ;
5486 int res1 = 0 ;
5487 wxRealPoint temp2 ;
5488 PyObject * obj0 = 0 ;
5489 PyObject * obj1 = 0 ;
5490 char * kwnames[] = {
5491 (char *) "self",(char *) "pt", NULL
5492 };
5493
5494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5496 if (!SWIG_IsOK(res1)) {
5497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5498 }
5499 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5500 {
5501 arg2 = &temp2;
5502 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5503 }
5504 {
5505 PyThreadState* __tstate = wxPyBeginAllowThreads();
5506 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5507 wxPyEndAllowThreads(__tstate);
5508 if (PyErr_Occurred()) SWIG_fail;
5509 }
5510 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5511 return resultobj;
5512 fail:
5513 return NULL;
5514 }
5515
5516
5517 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5518 PyObject *resultobj = 0;
5519 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5520 double arg2 ;
5521 double arg3 ;
5522 void *argp1 = 0 ;
5523 int res1 = 0 ;
5524 double val2 ;
5525 int ecode2 = 0 ;
5526 double val3 ;
5527 int ecode3 = 0 ;
5528 PyObject * obj0 = 0 ;
5529 PyObject * obj1 = 0 ;
5530 PyObject * obj2 = 0 ;
5531 char * kwnames[] = {
5532 (char *) "self",(char *) "x",(char *) "y", NULL
5533 };
5534
5535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5537 if (!SWIG_IsOK(res1)) {
5538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5539 }
5540 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5541 ecode2 = SWIG_AsVal_double(obj1, &val2);
5542 if (!SWIG_IsOK(ecode2)) {
5543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5544 }
5545 arg2 = static_cast< double >(val2);
5546 ecode3 = SWIG_AsVal_double(obj2, &val3);
5547 if (!SWIG_IsOK(ecode3)) {
5548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5549 }
5550 arg3 = static_cast< double >(val3);
5551 {
5552 PyThreadState* __tstate = wxPyBeginAllowThreads();
5553 wxRealPoint_Set(arg1,arg2,arg3);
5554 wxPyEndAllowThreads(__tstate);
5555 if (PyErr_Occurred()) SWIG_fail;
5556 }
5557 resultobj = SWIG_Py_Void();
5558 return resultobj;
5559 fail:
5560 return NULL;
5561 }
5562
5563
5564 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5565 PyObject *resultobj = 0;
5566 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5567 PyObject *result = 0 ;
5568 void *argp1 = 0 ;
5569 int res1 = 0 ;
5570 PyObject *swig_obj[1] ;
5571
5572 if (!args) SWIG_fail;
5573 swig_obj[0] = args;
5574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5575 if (!SWIG_IsOK(res1)) {
5576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5577 }
5578 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5579 {
5580 PyThreadState* __tstate = wxPyBeginAllowThreads();
5581 result = (PyObject *)wxRealPoint_Get(arg1);
5582 wxPyEndAllowThreads(__tstate);
5583 if (PyErr_Occurred()) SWIG_fail;
5584 }
5585 resultobj = result;
5586 return resultobj;
5587 fail:
5588 return NULL;
5589 }
5590
5591
5592 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5593 PyObject *obj;
5594 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5595 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5596 return SWIG_Py_Void();
5597 }
5598
5599 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5600 return SWIG_Python_InitShadowInstance(args);
5601 }
5602
5603 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5604 PyObject *resultobj = 0;
5605 wxPoint *arg1 = (wxPoint *) 0 ;
5606 int arg2 ;
5607 void *argp1 = 0 ;
5608 int res1 = 0 ;
5609 int val2 ;
5610 int ecode2 = 0 ;
5611 PyObject *swig_obj[2] ;
5612
5613 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5615 if (!SWIG_IsOK(res1)) {
5616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5617 }
5618 arg1 = reinterpret_cast< wxPoint * >(argp1);
5619 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5620 if (!SWIG_IsOK(ecode2)) {
5621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5622 }
5623 arg2 = static_cast< int >(val2);
5624 if (arg1) (arg1)->x = arg2;
5625
5626 resultobj = SWIG_Py_Void();
5627 return resultobj;
5628 fail:
5629 return NULL;
5630 }
5631
5632
5633 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5634 PyObject *resultobj = 0;
5635 wxPoint *arg1 = (wxPoint *) 0 ;
5636 int result;
5637 void *argp1 = 0 ;
5638 int res1 = 0 ;
5639 PyObject *swig_obj[1] ;
5640
5641 if (!args) SWIG_fail;
5642 swig_obj[0] = args;
5643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5644 if (!SWIG_IsOK(res1)) {
5645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5646 }
5647 arg1 = reinterpret_cast< wxPoint * >(argp1);
5648 result = (int) ((arg1)->x);
5649 resultobj = SWIG_From_int(static_cast< int >(result));
5650 return resultobj;
5651 fail:
5652 return NULL;
5653 }
5654
5655
5656 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5657 PyObject *resultobj = 0;
5658 wxPoint *arg1 = (wxPoint *) 0 ;
5659 int arg2 ;
5660 void *argp1 = 0 ;
5661 int res1 = 0 ;
5662 int val2 ;
5663 int ecode2 = 0 ;
5664 PyObject *swig_obj[2] ;
5665
5666 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5668 if (!SWIG_IsOK(res1)) {
5669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5670 }
5671 arg1 = reinterpret_cast< wxPoint * >(argp1);
5672 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5673 if (!SWIG_IsOK(ecode2)) {
5674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5675 }
5676 arg2 = static_cast< int >(val2);
5677 if (arg1) (arg1)->y = arg2;
5678
5679 resultobj = SWIG_Py_Void();
5680 return resultobj;
5681 fail:
5682 return NULL;
5683 }
5684
5685
5686 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5687 PyObject *resultobj = 0;
5688 wxPoint *arg1 = (wxPoint *) 0 ;
5689 int result;
5690 void *argp1 = 0 ;
5691 int res1 = 0 ;
5692 PyObject *swig_obj[1] ;
5693
5694 if (!args) SWIG_fail;
5695 swig_obj[0] = args;
5696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5697 if (!SWIG_IsOK(res1)) {
5698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5699 }
5700 arg1 = reinterpret_cast< wxPoint * >(argp1);
5701 result = (int) ((arg1)->y);
5702 resultobj = SWIG_From_int(static_cast< int >(result));
5703 return resultobj;
5704 fail:
5705 return NULL;
5706 }
5707
5708
5709 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5710 PyObject *resultobj = 0;
5711 int arg1 = (int) 0 ;
5712 int arg2 = (int) 0 ;
5713 wxPoint *result = 0 ;
5714 int val1 ;
5715 int ecode1 = 0 ;
5716 int val2 ;
5717 int ecode2 = 0 ;
5718 PyObject * obj0 = 0 ;
5719 PyObject * obj1 = 0 ;
5720 char * kwnames[] = {
5721 (char *) "x",(char *) "y", NULL
5722 };
5723
5724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5725 if (obj0) {
5726 ecode1 = SWIG_AsVal_int(obj0, &val1);
5727 if (!SWIG_IsOK(ecode1)) {
5728 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5729 }
5730 arg1 = static_cast< int >(val1);
5731 }
5732 if (obj1) {
5733 ecode2 = SWIG_AsVal_int(obj1, &val2);
5734 if (!SWIG_IsOK(ecode2)) {
5735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5736 }
5737 arg2 = static_cast< int >(val2);
5738 }
5739 {
5740 PyThreadState* __tstate = wxPyBeginAllowThreads();
5741 result = (wxPoint *)new wxPoint(arg1,arg2);
5742 wxPyEndAllowThreads(__tstate);
5743 if (PyErr_Occurred()) SWIG_fail;
5744 }
5745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5753 PyObject *resultobj = 0;
5754 wxPoint *arg1 = (wxPoint *) 0 ;
5755 void *argp1 = 0 ;
5756 int res1 = 0 ;
5757 PyObject *swig_obj[1] ;
5758
5759 if (!args) SWIG_fail;
5760 swig_obj[0] = args;
5761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5762 if (!SWIG_IsOK(res1)) {
5763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5764 }
5765 arg1 = reinterpret_cast< wxPoint * >(argp1);
5766 {
5767 PyThreadState* __tstate = wxPyBeginAllowThreads();
5768 delete arg1;
5769
5770 wxPyEndAllowThreads(__tstate);
5771 if (PyErr_Occurred()) SWIG_fail;
5772 }
5773 resultobj = SWIG_Py_Void();
5774 return resultobj;
5775 fail:
5776 return NULL;
5777 }
5778
5779
5780 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5781 PyObject *resultobj = 0;
5782 wxPoint *arg1 = (wxPoint *) 0 ;
5783 PyObject *arg2 = (PyObject *) 0 ;
5784 bool result;
5785 void *argp1 = 0 ;
5786 int res1 = 0 ;
5787 PyObject * obj0 = 0 ;
5788 PyObject * obj1 = 0 ;
5789 char * kwnames[] = {
5790 (char *) "self",(char *) "other", NULL
5791 };
5792
5793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5795 if (!SWIG_IsOK(res1)) {
5796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5797 }
5798 arg1 = reinterpret_cast< wxPoint * >(argp1);
5799 arg2 = obj1;
5800 {
5801 result = (bool)wxPoint___eq__(arg1,arg2);
5802 if (PyErr_Occurred()) SWIG_fail;
5803 }
5804 {
5805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5806 }
5807 return resultobj;
5808 fail:
5809 return NULL;
5810 }
5811
5812
5813 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5814 PyObject *resultobj = 0;
5815 wxPoint *arg1 = (wxPoint *) 0 ;
5816 PyObject *arg2 = (PyObject *) 0 ;
5817 bool result;
5818 void *argp1 = 0 ;
5819 int res1 = 0 ;
5820 PyObject * obj0 = 0 ;
5821 PyObject * obj1 = 0 ;
5822 char * kwnames[] = {
5823 (char *) "self",(char *) "other", NULL
5824 };
5825
5826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5828 if (!SWIG_IsOK(res1)) {
5829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5830 }
5831 arg1 = reinterpret_cast< wxPoint * >(argp1);
5832 arg2 = obj1;
5833 {
5834 result = (bool)wxPoint___ne__(arg1,arg2);
5835 if (PyErr_Occurred()) SWIG_fail;
5836 }
5837 {
5838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5839 }
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj = 0;
5848 wxPoint *arg1 = (wxPoint *) 0 ;
5849 wxPoint *arg2 = 0 ;
5850 wxPoint result;
5851 void *argp1 = 0 ;
5852 int res1 = 0 ;
5853 wxPoint temp2 ;
5854 PyObject * obj0 = 0 ;
5855 PyObject * obj1 = 0 ;
5856 char * kwnames[] = {
5857 (char *) "self",(char *) "pt", NULL
5858 };
5859
5860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5862 if (!SWIG_IsOK(res1)) {
5863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5864 }
5865 arg1 = reinterpret_cast< wxPoint * >(argp1);
5866 {
5867 arg2 = &temp2;
5868 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5869 }
5870 {
5871 PyThreadState* __tstate = wxPyBeginAllowThreads();
5872 result = (arg1)->operator +((wxPoint const &)*arg2);
5873 wxPyEndAllowThreads(__tstate);
5874 if (PyErr_Occurred()) SWIG_fail;
5875 }
5876 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5877 return resultobj;
5878 fail:
5879 return NULL;
5880 }
5881
5882
5883 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5884 PyObject *resultobj = 0;
5885 wxPoint *arg1 = (wxPoint *) 0 ;
5886 wxPoint *arg2 = 0 ;
5887 wxPoint result;
5888 void *argp1 = 0 ;
5889 int res1 = 0 ;
5890 wxPoint temp2 ;
5891 PyObject * obj0 = 0 ;
5892 PyObject * obj1 = 0 ;
5893 char * kwnames[] = {
5894 (char *) "self",(char *) "pt", NULL
5895 };
5896
5897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5899 if (!SWIG_IsOK(res1)) {
5900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5901 }
5902 arg1 = reinterpret_cast< wxPoint * >(argp1);
5903 {
5904 arg2 = &temp2;
5905 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5906 }
5907 {
5908 PyThreadState* __tstate = wxPyBeginAllowThreads();
5909 result = (arg1)->operator -((wxPoint const &)*arg2);
5910 wxPyEndAllowThreads(__tstate);
5911 if (PyErr_Occurred()) SWIG_fail;
5912 }
5913 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5914 return resultobj;
5915 fail:
5916 return NULL;
5917 }
5918
5919
5920 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5921 PyObject *resultobj = 0;
5922 wxPoint *arg1 = (wxPoint *) 0 ;
5923 wxPoint *arg2 = 0 ;
5924 wxPoint *result = 0 ;
5925 void *argp1 = 0 ;
5926 int res1 = 0 ;
5927 wxPoint temp2 ;
5928 PyObject * obj0 = 0 ;
5929 PyObject * obj1 = 0 ;
5930 char * kwnames[] = {
5931 (char *) "self",(char *) "pt", NULL
5932 };
5933
5934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5936 if (!SWIG_IsOK(res1)) {
5937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5938 }
5939 arg1 = reinterpret_cast< wxPoint * >(argp1);
5940 {
5941 arg2 = &temp2;
5942 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5943 }
5944 {
5945 PyThreadState* __tstate = wxPyBeginAllowThreads();
5946 {
5947 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5948 result = (wxPoint *) &_result_ref;
5949 }
5950 wxPyEndAllowThreads(__tstate);
5951 if (PyErr_Occurred()) SWIG_fail;
5952 }
5953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5954 return resultobj;
5955 fail:
5956 return NULL;
5957 }
5958
5959
5960 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5961 PyObject *resultobj = 0;
5962 wxPoint *arg1 = (wxPoint *) 0 ;
5963 wxPoint *arg2 = 0 ;
5964 wxPoint *result = 0 ;
5965 void *argp1 = 0 ;
5966 int res1 = 0 ;
5967 wxPoint temp2 ;
5968 PyObject * obj0 = 0 ;
5969 PyObject * obj1 = 0 ;
5970 char * kwnames[] = {
5971 (char *) "self",(char *) "pt", NULL
5972 };
5973
5974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5976 if (!SWIG_IsOK(res1)) {
5977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5978 }
5979 arg1 = reinterpret_cast< wxPoint * >(argp1);
5980 {
5981 arg2 = &temp2;
5982 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5983 }
5984 {
5985 PyThreadState* __tstate = wxPyBeginAllowThreads();
5986 {
5987 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5988 result = (wxPoint *) &_result_ref;
5989 }
5990 wxPyEndAllowThreads(__tstate);
5991 if (PyErr_Occurred()) SWIG_fail;
5992 }
5993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5994 return resultobj;
5995 fail:
5996 return NULL;
5997 }
5998
5999
6000 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6001 PyObject *resultobj = 0;
6002 wxPoint *arg1 = (wxPoint *) 0 ;
6003 long arg2 ;
6004 long arg3 ;
6005 void *argp1 = 0 ;
6006 int res1 = 0 ;
6007 long val2 ;
6008 int ecode2 = 0 ;
6009 long val3 ;
6010 int ecode3 = 0 ;
6011 PyObject * obj0 = 0 ;
6012 PyObject * obj1 = 0 ;
6013 PyObject * obj2 = 0 ;
6014 char * kwnames[] = {
6015 (char *) "self",(char *) "x",(char *) "y", NULL
6016 };
6017
6018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6020 if (!SWIG_IsOK(res1)) {
6021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6022 }
6023 arg1 = reinterpret_cast< wxPoint * >(argp1);
6024 ecode2 = SWIG_AsVal_long(obj1, &val2);
6025 if (!SWIG_IsOK(ecode2)) {
6026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6027 }
6028 arg2 = static_cast< long >(val2);
6029 ecode3 = SWIG_AsVal_long(obj2, &val3);
6030 if (!SWIG_IsOK(ecode3)) {
6031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6032 }
6033 arg3 = static_cast< long >(val3);
6034 {
6035 PyThreadState* __tstate = wxPyBeginAllowThreads();
6036 wxPoint_Set(arg1,arg2,arg3);
6037 wxPyEndAllowThreads(__tstate);
6038 if (PyErr_Occurred()) SWIG_fail;
6039 }
6040 resultobj = SWIG_Py_Void();
6041 return resultobj;
6042 fail:
6043 return NULL;
6044 }
6045
6046
6047 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6048 PyObject *resultobj = 0;
6049 wxPoint *arg1 = (wxPoint *) 0 ;
6050 PyObject *result = 0 ;
6051 void *argp1 = 0 ;
6052 int res1 = 0 ;
6053 PyObject *swig_obj[1] ;
6054
6055 if (!args) SWIG_fail;
6056 swig_obj[0] = args;
6057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6058 if (!SWIG_IsOK(res1)) {
6059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6060 }
6061 arg1 = reinterpret_cast< wxPoint * >(argp1);
6062 {
6063 PyThreadState* __tstate = wxPyBeginAllowThreads();
6064 result = (PyObject *)wxPoint_Get(arg1);
6065 wxPyEndAllowThreads(__tstate);
6066 if (PyErr_Occurred()) SWIG_fail;
6067 }
6068 resultobj = result;
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6076 PyObject *obj;
6077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6078 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6079 return SWIG_Py_Void();
6080 }
6081
6082 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6083 return SWIG_Python_InitShadowInstance(args);
6084 }
6085
6086 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6087 PyObject *resultobj = 0;
6088 int arg1 = (int) 0 ;
6089 int arg2 = (int) 0 ;
6090 int arg3 = (int) 0 ;
6091 int arg4 = (int) 0 ;
6092 wxRect *result = 0 ;
6093 int val1 ;
6094 int ecode1 = 0 ;
6095 int val2 ;
6096 int ecode2 = 0 ;
6097 int val3 ;
6098 int ecode3 = 0 ;
6099 int val4 ;
6100 int ecode4 = 0 ;
6101 PyObject * obj0 = 0 ;
6102 PyObject * obj1 = 0 ;
6103 PyObject * obj2 = 0 ;
6104 PyObject * obj3 = 0 ;
6105 char * kwnames[] = {
6106 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6107 };
6108
6109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6110 if (obj0) {
6111 ecode1 = SWIG_AsVal_int(obj0, &val1);
6112 if (!SWIG_IsOK(ecode1)) {
6113 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6114 }
6115 arg1 = static_cast< int >(val1);
6116 }
6117 if (obj1) {
6118 ecode2 = SWIG_AsVal_int(obj1, &val2);
6119 if (!SWIG_IsOK(ecode2)) {
6120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6121 }
6122 arg2 = static_cast< int >(val2);
6123 }
6124 if (obj2) {
6125 ecode3 = SWIG_AsVal_int(obj2, &val3);
6126 if (!SWIG_IsOK(ecode3)) {
6127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6128 }
6129 arg3 = static_cast< int >(val3);
6130 }
6131 if (obj3) {
6132 ecode4 = SWIG_AsVal_int(obj3, &val4);
6133 if (!SWIG_IsOK(ecode4)) {
6134 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6135 }
6136 arg4 = static_cast< int >(val4);
6137 }
6138 {
6139 PyThreadState* __tstate = wxPyBeginAllowThreads();
6140 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6141 wxPyEndAllowThreads(__tstate);
6142 if (PyErr_Occurred()) SWIG_fail;
6143 }
6144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6145 return resultobj;
6146 fail:
6147 return NULL;
6148 }
6149
6150
6151 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6152 PyObject *resultobj = 0;
6153 wxPoint *arg1 = 0 ;
6154 wxPoint *arg2 = 0 ;
6155 wxRect *result = 0 ;
6156 wxPoint temp1 ;
6157 wxPoint temp2 ;
6158 PyObject * obj0 = 0 ;
6159 PyObject * obj1 = 0 ;
6160 char * kwnames[] = {
6161 (char *) "topLeft",(char *) "bottomRight", NULL
6162 };
6163
6164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6165 {
6166 arg1 = &temp1;
6167 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6168 }
6169 {
6170 arg2 = &temp2;
6171 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6172 }
6173 {
6174 PyThreadState* __tstate = wxPyBeginAllowThreads();
6175 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6176 wxPyEndAllowThreads(__tstate);
6177 if (PyErr_Occurred()) SWIG_fail;
6178 }
6179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6180 return resultobj;
6181 fail:
6182 return NULL;
6183 }
6184
6185
6186 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6187 PyObject *resultobj = 0;
6188 wxPoint *arg1 = 0 ;
6189 wxSize *arg2 = 0 ;
6190 wxRect *result = 0 ;
6191 wxPoint temp1 ;
6192 wxSize temp2 ;
6193 PyObject * obj0 = 0 ;
6194 PyObject * obj1 = 0 ;
6195 char * kwnames[] = {
6196 (char *) "pos",(char *) "size", NULL
6197 };
6198
6199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6200 {
6201 arg1 = &temp1;
6202 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6203 }
6204 {
6205 arg2 = &temp2;
6206 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6207 }
6208 {
6209 PyThreadState* __tstate = wxPyBeginAllowThreads();
6210 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6211 wxPyEndAllowThreads(__tstate);
6212 if (PyErr_Occurred()) SWIG_fail;
6213 }
6214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6215 return resultobj;
6216 fail:
6217 return NULL;
6218 }
6219
6220
6221 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6222 PyObject *resultobj = 0;
6223 wxSize *arg1 = 0 ;
6224 wxRect *result = 0 ;
6225 wxSize temp1 ;
6226 PyObject * obj0 = 0 ;
6227 char * kwnames[] = {
6228 (char *) "size", NULL
6229 };
6230
6231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6232 {
6233 arg1 = &temp1;
6234 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6235 }
6236 {
6237 PyThreadState* __tstate = wxPyBeginAllowThreads();
6238 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6239 wxPyEndAllowThreads(__tstate);
6240 if (PyErr_Occurred()) SWIG_fail;
6241 }
6242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6243 return resultobj;
6244 fail:
6245 return NULL;
6246 }
6247
6248
6249 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6250 PyObject *resultobj = 0;
6251 wxRect *arg1 = (wxRect *) 0 ;
6252 void *argp1 = 0 ;
6253 int res1 = 0 ;
6254 PyObject *swig_obj[1] ;
6255
6256 if (!args) SWIG_fail;
6257 swig_obj[0] = args;
6258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6259 if (!SWIG_IsOK(res1)) {
6260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6261 }
6262 arg1 = reinterpret_cast< wxRect * >(argp1);
6263 {
6264 PyThreadState* __tstate = wxPyBeginAllowThreads();
6265 delete arg1;
6266
6267 wxPyEndAllowThreads(__tstate);
6268 if (PyErr_Occurred()) SWIG_fail;
6269 }
6270 resultobj = SWIG_Py_Void();
6271 return resultobj;
6272 fail:
6273 return NULL;
6274 }
6275
6276
6277 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6278 PyObject *resultobj = 0;
6279 wxRect *arg1 = (wxRect *) 0 ;
6280 int result;
6281 void *argp1 = 0 ;
6282 int res1 = 0 ;
6283 PyObject *swig_obj[1] ;
6284
6285 if (!args) SWIG_fail;
6286 swig_obj[0] = args;
6287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6288 if (!SWIG_IsOK(res1)) {
6289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6290 }
6291 arg1 = reinterpret_cast< wxRect * >(argp1);
6292 {
6293 PyThreadState* __tstate = wxPyBeginAllowThreads();
6294 result = (int)((wxRect const *)arg1)->GetX();
6295 wxPyEndAllowThreads(__tstate);
6296 if (PyErr_Occurred()) SWIG_fail;
6297 }
6298 resultobj = SWIG_From_int(static_cast< int >(result));
6299 return resultobj;
6300 fail:
6301 return NULL;
6302 }
6303
6304
6305 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6306 PyObject *resultobj = 0;
6307 wxRect *arg1 = (wxRect *) 0 ;
6308 int arg2 ;
6309 void *argp1 = 0 ;
6310 int res1 = 0 ;
6311 int val2 ;
6312 int ecode2 = 0 ;
6313 PyObject * obj0 = 0 ;
6314 PyObject * obj1 = 0 ;
6315 char * kwnames[] = {
6316 (char *) "self",(char *) "x", NULL
6317 };
6318
6319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6321 if (!SWIG_IsOK(res1)) {
6322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6323 }
6324 arg1 = reinterpret_cast< wxRect * >(argp1);
6325 ecode2 = SWIG_AsVal_int(obj1, &val2);
6326 if (!SWIG_IsOK(ecode2)) {
6327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6328 }
6329 arg2 = static_cast< int >(val2);
6330 {
6331 PyThreadState* __tstate = wxPyBeginAllowThreads();
6332 (arg1)->SetX(arg2);
6333 wxPyEndAllowThreads(__tstate);
6334 if (PyErr_Occurred()) SWIG_fail;
6335 }
6336 resultobj = SWIG_Py_Void();
6337 return resultobj;
6338 fail:
6339 return NULL;
6340 }
6341
6342
6343 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6344 PyObject *resultobj = 0;
6345 wxRect *arg1 = (wxRect *) 0 ;
6346 int result;
6347 void *argp1 = 0 ;
6348 int res1 = 0 ;
6349 PyObject *swig_obj[1] ;
6350
6351 if (!args) SWIG_fail;
6352 swig_obj[0] = args;
6353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6354 if (!SWIG_IsOK(res1)) {
6355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6356 }
6357 arg1 = reinterpret_cast< wxRect * >(argp1);
6358 {
6359 PyThreadState* __tstate = wxPyBeginAllowThreads();
6360 result = (int)(arg1)->GetY();
6361 wxPyEndAllowThreads(__tstate);
6362 if (PyErr_Occurred()) SWIG_fail;
6363 }
6364 resultobj = SWIG_From_int(static_cast< int >(result));
6365 return resultobj;
6366 fail:
6367 return NULL;
6368 }
6369
6370
6371 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6372 PyObject *resultobj = 0;
6373 wxRect *arg1 = (wxRect *) 0 ;
6374 int arg2 ;
6375 void *argp1 = 0 ;
6376 int res1 = 0 ;
6377 int val2 ;
6378 int ecode2 = 0 ;
6379 PyObject * obj0 = 0 ;
6380 PyObject * obj1 = 0 ;
6381 char * kwnames[] = {
6382 (char *) "self",(char *) "y", NULL
6383 };
6384
6385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6387 if (!SWIG_IsOK(res1)) {
6388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6389 }
6390 arg1 = reinterpret_cast< wxRect * >(argp1);
6391 ecode2 = SWIG_AsVal_int(obj1, &val2);
6392 if (!SWIG_IsOK(ecode2)) {
6393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6394 }
6395 arg2 = static_cast< int >(val2);
6396 {
6397 PyThreadState* __tstate = wxPyBeginAllowThreads();
6398 (arg1)->SetY(arg2);
6399 wxPyEndAllowThreads(__tstate);
6400 if (PyErr_Occurred()) SWIG_fail;
6401 }
6402 resultobj = SWIG_Py_Void();
6403 return resultobj;
6404 fail:
6405 return NULL;
6406 }
6407
6408
6409 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6410 PyObject *resultobj = 0;
6411 wxRect *arg1 = (wxRect *) 0 ;
6412 int result;
6413 void *argp1 = 0 ;
6414 int res1 = 0 ;
6415 PyObject *swig_obj[1] ;
6416
6417 if (!args) SWIG_fail;
6418 swig_obj[0] = args;
6419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6420 if (!SWIG_IsOK(res1)) {
6421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6422 }
6423 arg1 = reinterpret_cast< wxRect * >(argp1);
6424 {
6425 PyThreadState* __tstate = wxPyBeginAllowThreads();
6426 result = (int)((wxRect const *)arg1)->GetWidth();
6427 wxPyEndAllowThreads(__tstate);
6428 if (PyErr_Occurred()) SWIG_fail;
6429 }
6430 resultobj = SWIG_From_int(static_cast< int >(result));
6431 return resultobj;
6432 fail:
6433 return NULL;
6434 }
6435
6436
6437 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6438 PyObject *resultobj = 0;
6439 wxRect *arg1 = (wxRect *) 0 ;
6440 int arg2 ;
6441 void *argp1 = 0 ;
6442 int res1 = 0 ;
6443 int val2 ;
6444 int ecode2 = 0 ;
6445 PyObject * obj0 = 0 ;
6446 PyObject * obj1 = 0 ;
6447 char * kwnames[] = {
6448 (char *) "self",(char *) "w", NULL
6449 };
6450
6451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6453 if (!SWIG_IsOK(res1)) {
6454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6455 }
6456 arg1 = reinterpret_cast< wxRect * >(argp1);
6457 ecode2 = SWIG_AsVal_int(obj1, &val2);
6458 if (!SWIG_IsOK(ecode2)) {
6459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6460 }
6461 arg2 = static_cast< int >(val2);
6462 {
6463 PyThreadState* __tstate = wxPyBeginAllowThreads();
6464 (arg1)->SetWidth(arg2);
6465 wxPyEndAllowThreads(__tstate);
6466 if (PyErr_Occurred()) SWIG_fail;
6467 }
6468 resultobj = SWIG_Py_Void();
6469 return resultobj;
6470 fail:
6471 return NULL;
6472 }
6473
6474
6475 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6476 PyObject *resultobj = 0;
6477 wxRect *arg1 = (wxRect *) 0 ;
6478 int result;
6479 void *argp1 = 0 ;
6480 int res1 = 0 ;
6481 PyObject *swig_obj[1] ;
6482
6483 if (!args) SWIG_fail;
6484 swig_obj[0] = args;
6485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6486 if (!SWIG_IsOK(res1)) {
6487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6488 }
6489 arg1 = reinterpret_cast< wxRect * >(argp1);
6490 {
6491 PyThreadState* __tstate = wxPyBeginAllowThreads();
6492 result = (int)((wxRect const *)arg1)->GetHeight();
6493 wxPyEndAllowThreads(__tstate);
6494 if (PyErr_Occurred()) SWIG_fail;
6495 }
6496 resultobj = SWIG_From_int(static_cast< int >(result));
6497 return resultobj;
6498 fail:
6499 return NULL;
6500 }
6501
6502
6503 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6504 PyObject *resultobj = 0;
6505 wxRect *arg1 = (wxRect *) 0 ;
6506 int arg2 ;
6507 void *argp1 = 0 ;
6508 int res1 = 0 ;
6509 int val2 ;
6510 int ecode2 = 0 ;
6511 PyObject * obj0 = 0 ;
6512 PyObject * obj1 = 0 ;
6513 char * kwnames[] = {
6514 (char *) "self",(char *) "h", NULL
6515 };
6516
6517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6519 if (!SWIG_IsOK(res1)) {
6520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6521 }
6522 arg1 = reinterpret_cast< wxRect * >(argp1);
6523 ecode2 = SWIG_AsVal_int(obj1, &val2);
6524 if (!SWIG_IsOK(ecode2)) {
6525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6526 }
6527 arg2 = static_cast< int >(val2);
6528 {
6529 PyThreadState* __tstate = wxPyBeginAllowThreads();
6530 (arg1)->SetHeight(arg2);
6531 wxPyEndAllowThreads(__tstate);
6532 if (PyErr_Occurred()) SWIG_fail;
6533 }
6534 resultobj = SWIG_Py_Void();
6535 return resultobj;
6536 fail:
6537 return NULL;
6538 }
6539
6540
6541 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6542 PyObject *resultobj = 0;
6543 wxRect *arg1 = (wxRect *) 0 ;
6544 wxPoint result;
6545 void *argp1 = 0 ;
6546 int res1 = 0 ;
6547 PyObject *swig_obj[1] ;
6548
6549 if (!args) SWIG_fail;
6550 swig_obj[0] = args;
6551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6552 if (!SWIG_IsOK(res1)) {
6553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6554 }
6555 arg1 = reinterpret_cast< wxRect * >(argp1);
6556 {
6557 PyThreadState* __tstate = wxPyBeginAllowThreads();
6558 result = ((wxRect const *)arg1)->GetPosition();
6559 wxPyEndAllowThreads(__tstate);
6560 if (PyErr_Occurred()) SWIG_fail;
6561 }
6562 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6570 PyObject *resultobj = 0;
6571 wxRect *arg1 = (wxRect *) 0 ;
6572 wxPoint *arg2 = 0 ;
6573 void *argp1 = 0 ;
6574 int res1 = 0 ;
6575 wxPoint temp2 ;
6576 PyObject * obj0 = 0 ;
6577 PyObject * obj1 = 0 ;
6578 char * kwnames[] = {
6579 (char *) "self",(char *) "p", NULL
6580 };
6581
6582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6584 if (!SWIG_IsOK(res1)) {
6585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6586 }
6587 arg1 = reinterpret_cast< wxRect * >(argp1);
6588 {
6589 arg2 = &temp2;
6590 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6591 }
6592 {
6593 PyThreadState* __tstate = wxPyBeginAllowThreads();
6594 (arg1)->SetPosition((wxPoint const &)*arg2);
6595 wxPyEndAllowThreads(__tstate);
6596 if (PyErr_Occurred()) SWIG_fail;
6597 }
6598 resultobj = SWIG_Py_Void();
6599 return resultobj;
6600 fail:
6601 return NULL;
6602 }
6603
6604
6605 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6606 PyObject *resultobj = 0;
6607 wxRect *arg1 = (wxRect *) 0 ;
6608 wxSize result;
6609 void *argp1 = 0 ;
6610 int res1 = 0 ;
6611 PyObject *swig_obj[1] ;
6612
6613 if (!args) SWIG_fail;
6614 swig_obj[0] = args;
6615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6616 if (!SWIG_IsOK(res1)) {
6617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6618 }
6619 arg1 = reinterpret_cast< wxRect * >(argp1);
6620 {
6621 PyThreadState* __tstate = wxPyBeginAllowThreads();
6622 result = ((wxRect const *)arg1)->GetSize();
6623 wxPyEndAllowThreads(__tstate);
6624 if (PyErr_Occurred()) SWIG_fail;
6625 }
6626 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6627 return resultobj;
6628 fail:
6629 return NULL;
6630 }
6631
6632
6633 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6634 PyObject *resultobj = 0;
6635 wxRect *arg1 = (wxRect *) 0 ;
6636 wxSize *arg2 = 0 ;
6637 void *argp1 = 0 ;
6638 int res1 = 0 ;
6639 wxSize temp2 ;
6640 PyObject * obj0 = 0 ;
6641 PyObject * obj1 = 0 ;
6642 char * kwnames[] = {
6643 (char *) "self",(char *) "s", NULL
6644 };
6645
6646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6648 if (!SWIG_IsOK(res1)) {
6649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6650 }
6651 arg1 = reinterpret_cast< wxRect * >(argp1);
6652 {
6653 arg2 = &temp2;
6654 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6655 }
6656 {
6657 PyThreadState* __tstate = wxPyBeginAllowThreads();
6658 (arg1)->SetSize((wxSize const &)*arg2);
6659 wxPyEndAllowThreads(__tstate);
6660 if (PyErr_Occurred()) SWIG_fail;
6661 }
6662 resultobj = SWIG_Py_Void();
6663 return resultobj;
6664 fail:
6665 return NULL;
6666 }
6667
6668
6669 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6670 PyObject *resultobj = 0;
6671 wxRect *arg1 = (wxRect *) 0 ;
6672 bool result;
6673 void *argp1 = 0 ;
6674 int res1 = 0 ;
6675 PyObject *swig_obj[1] ;
6676
6677 if (!args) SWIG_fail;
6678 swig_obj[0] = args;
6679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6680 if (!SWIG_IsOK(res1)) {
6681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6682 }
6683 arg1 = reinterpret_cast< wxRect * >(argp1);
6684 {
6685 PyThreadState* __tstate = wxPyBeginAllowThreads();
6686 result = (bool)((wxRect const *)arg1)->IsEmpty();
6687 wxPyEndAllowThreads(__tstate);
6688 if (PyErr_Occurred()) SWIG_fail;
6689 }
6690 {
6691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6692 }
6693 return resultobj;
6694 fail:
6695 return NULL;
6696 }
6697
6698
6699 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6700 PyObject *resultobj = 0;
6701 wxRect *arg1 = (wxRect *) 0 ;
6702 wxPoint result;
6703 void *argp1 = 0 ;
6704 int res1 = 0 ;
6705 PyObject *swig_obj[1] ;
6706
6707 if (!args) SWIG_fail;
6708 swig_obj[0] = args;
6709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6710 if (!SWIG_IsOK(res1)) {
6711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6712 }
6713 arg1 = reinterpret_cast< wxRect * >(argp1);
6714 {
6715 PyThreadState* __tstate = wxPyBeginAllowThreads();
6716 result = ((wxRect const *)arg1)->GetTopLeft();
6717 wxPyEndAllowThreads(__tstate);
6718 if (PyErr_Occurred()) SWIG_fail;
6719 }
6720 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6721 return resultobj;
6722 fail:
6723 return NULL;
6724 }
6725
6726
6727 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6728 PyObject *resultobj = 0;
6729 wxRect *arg1 = (wxRect *) 0 ;
6730 wxPoint *arg2 = 0 ;
6731 void *argp1 = 0 ;
6732 int res1 = 0 ;
6733 wxPoint temp2 ;
6734 PyObject * obj0 = 0 ;
6735 PyObject * obj1 = 0 ;
6736 char * kwnames[] = {
6737 (char *) "self",(char *) "p", NULL
6738 };
6739
6740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6742 if (!SWIG_IsOK(res1)) {
6743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6744 }
6745 arg1 = reinterpret_cast< wxRect * >(argp1);
6746 {
6747 arg2 = &temp2;
6748 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6749 }
6750 {
6751 PyThreadState* __tstate = wxPyBeginAllowThreads();
6752 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6753 wxPyEndAllowThreads(__tstate);
6754 if (PyErr_Occurred()) SWIG_fail;
6755 }
6756 resultobj = SWIG_Py_Void();
6757 return resultobj;
6758 fail:
6759 return NULL;
6760 }
6761
6762
6763 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6764 PyObject *resultobj = 0;
6765 wxRect *arg1 = (wxRect *) 0 ;
6766 wxPoint result;
6767 void *argp1 = 0 ;
6768 int res1 = 0 ;
6769 PyObject *swig_obj[1] ;
6770
6771 if (!args) SWIG_fail;
6772 swig_obj[0] = args;
6773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6774 if (!SWIG_IsOK(res1)) {
6775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6776 }
6777 arg1 = reinterpret_cast< wxRect * >(argp1);
6778 {
6779 PyThreadState* __tstate = wxPyBeginAllowThreads();
6780 result = ((wxRect const *)arg1)->GetBottomRight();
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6792 PyObject *resultobj = 0;
6793 wxRect *arg1 = (wxRect *) 0 ;
6794 wxPoint *arg2 = 0 ;
6795 void *argp1 = 0 ;
6796 int res1 = 0 ;
6797 wxPoint temp2 ;
6798 PyObject * obj0 = 0 ;
6799 PyObject * obj1 = 0 ;
6800 char * kwnames[] = {
6801 (char *) "self",(char *) "p", NULL
6802 };
6803
6804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6806 if (!SWIG_IsOK(res1)) {
6807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6808 }
6809 arg1 = reinterpret_cast< wxRect * >(argp1);
6810 {
6811 arg2 = &temp2;
6812 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6813 }
6814 {
6815 PyThreadState* __tstate = wxPyBeginAllowThreads();
6816 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6817 wxPyEndAllowThreads(__tstate);
6818 if (PyErr_Occurred()) SWIG_fail;
6819 }
6820 resultobj = SWIG_Py_Void();
6821 return resultobj;
6822 fail:
6823 return NULL;
6824 }
6825
6826
6827 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6828 PyObject *resultobj = 0;
6829 wxRect *arg1 = (wxRect *) 0 ;
6830 int result;
6831 void *argp1 = 0 ;
6832 int res1 = 0 ;
6833 PyObject *swig_obj[1] ;
6834
6835 if (!args) SWIG_fail;
6836 swig_obj[0] = args;
6837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6838 if (!SWIG_IsOK(res1)) {
6839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6840 }
6841 arg1 = reinterpret_cast< wxRect * >(argp1);
6842 {
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 result = (int)((wxRect const *)arg1)->GetLeft();
6845 wxPyEndAllowThreads(__tstate);
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 resultobj = SWIG_From_int(static_cast< int >(result));
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6856 PyObject *resultobj = 0;
6857 wxRect *arg1 = (wxRect *) 0 ;
6858 int result;
6859 void *argp1 = 0 ;
6860 int res1 = 0 ;
6861 PyObject *swig_obj[1] ;
6862
6863 if (!args) SWIG_fail;
6864 swig_obj[0] = args;
6865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6866 if (!SWIG_IsOK(res1)) {
6867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6868 }
6869 arg1 = reinterpret_cast< wxRect * >(argp1);
6870 {
6871 PyThreadState* __tstate = wxPyBeginAllowThreads();
6872 result = (int)((wxRect const *)arg1)->GetTop();
6873 wxPyEndAllowThreads(__tstate);
6874 if (PyErr_Occurred()) SWIG_fail;
6875 }
6876 resultobj = SWIG_From_int(static_cast< int >(result));
6877 return resultobj;
6878 fail:
6879 return NULL;
6880 }
6881
6882
6883 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6884 PyObject *resultobj = 0;
6885 wxRect *arg1 = (wxRect *) 0 ;
6886 int result;
6887 void *argp1 = 0 ;
6888 int res1 = 0 ;
6889 PyObject *swig_obj[1] ;
6890
6891 if (!args) SWIG_fail;
6892 swig_obj[0] = args;
6893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6894 if (!SWIG_IsOK(res1)) {
6895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6896 }
6897 arg1 = reinterpret_cast< wxRect * >(argp1);
6898 {
6899 PyThreadState* __tstate = wxPyBeginAllowThreads();
6900 result = (int)((wxRect const *)arg1)->GetBottom();
6901 wxPyEndAllowThreads(__tstate);
6902 if (PyErr_Occurred()) SWIG_fail;
6903 }
6904 resultobj = SWIG_From_int(static_cast< int >(result));
6905 return resultobj;
6906 fail:
6907 return NULL;
6908 }
6909
6910
6911 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6912 PyObject *resultobj = 0;
6913 wxRect *arg1 = (wxRect *) 0 ;
6914 int result;
6915 void *argp1 = 0 ;
6916 int res1 = 0 ;
6917 PyObject *swig_obj[1] ;
6918
6919 if (!args) SWIG_fail;
6920 swig_obj[0] = args;
6921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6922 if (!SWIG_IsOK(res1)) {
6923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6924 }
6925 arg1 = reinterpret_cast< wxRect * >(argp1);
6926 {
6927 PyThreadState* __tstate = wxPyBeginAllowThreads();
6928 result = (int)((wxRect const *)arg1)->GetRight();
6929 wxPyEndAllowThreads(__tstate);
6930 if (PyErr_Occurred()) SWIG_fail;
6931 }
6932 resultobj = SWIG_From_int(static_cast< int >(result));
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6940 PyObject *resultobj = 0;
6941 wxRect *arg1 = (wxRect *) 0 ;
6942 int arg2 ;
6943 void *argp1 = 0 ;
6944 int res1 = 0 ;
6945 int val2 ;
6946 int ecode2 = 0 ;
6947 PyObject * obj0 = 0 ;
6948 PyObject * obj1 = 0 ;
6949 char * kwnames[] = {
6950 (char *) "self",(char *) "left", NULL
6951 };
6952
6953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6955 if (!SWIG_IsOK(res1)) {
6956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6957 }
6958 arg1 = reinterpret_cast< wxRect * >(argp1);
6959 ecode2 = SWIG_AsVal_int(obj1, &val2);
6960 if (!SWIG_IsOK(ecode2)) {
6961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6962 }
6963 arg2 = static_cast< int >(val2);
6964 {
6965 PyThreadState* __tstate = wxPyBeginAllowThreads();
6966 (arg1)->SetLeft(arg2);
6967 wxPyEndAllowThreads(__tstate);
6968 if (PyErr_Occurred()) SWIG_fail;
6969 }
6970 resultobj = SWIG_Py_Void();
6971 return resultobj;
6972 fail:
6973 return NULL;
6974 }
6975
6976
6977 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6978 PyObject *resultobj = 0;
6979 wxRect *arg1 = (wxRect *) 0 ;
6980 int arg2 ;
6981 void *argp1 = 0 ;
6982 int res1 = 0 ;
6983 int val2 ;
6984 int ecode2 = 0 ;
6985 PyObject * obj0 = 0 ;
6986 PyObject * obj1 = 0 ;
6987 char * kwnames[] = {
6988 (char *) "self",(char *) "right", NULL
6989 };
6990
6991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6993 if (!SWIG_IsOK(res1)) {
6994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6995 }
6996 arg1 = reinterpret_cast< wxRect * >(argp1);
6997 ecode2 = SWIG_AsVal_int(obj1, &val2);
6998 if (!SWIG_IsOK(ecode2)) {
6999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7000 }
7001 arg2 = static_cast< int >(val2);
7002 {
7003 PyThreadState* __tstate = wxPyBeginAllowThreads();
7004 (arg1)->SetRight(arg2);
7005 wxPyEndAllowThreads(__tstate);
7006 if (PyErr_Occurred()) SWIG_fail;
7007 }
7008 resultobj = SWIG_Py_Void();
7009 return resultobj;
7010 fail:
7011 return NULL;
7012 }
7013
7014
7015 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7016 PyObject *resultobj = 0;
7017 wxRect *arg1 = (wxRect *) 0 ;
7018 int arg2 ;
7019 void *argp1 = 0 ;
7020 int res1 = 0 ;
7021 int val2 ;
7022 int ecode2 = 0 ;
7023 PyObject * obj0 = 0 ;
7024 PyObject * obj1 = 0 ;
7025 char * kwnames[] = {
7026 (char *) "self",(char *) "top", NULL
7027 };
7028
7029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7031 if (!SWIG_IsOK(res1)) {
7032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7033 }
7034 arg1 = reinterpret_cast< wxRect * >(argp1);
7035 ecode2 = SWIG_AsVal_int(obj1, &val2);
7036 if (!SWIG_IsOK(ecode2)) {
7037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7038 }
7039 arg2 = static_cast< int >(val2);
7040 {
7041 PyThreadState* __tstate = wxPyBeginAllowThreads();
7042 (arg1)->SetTop(arg2);
7043 wxPyEndAllowThreads(__tstate);
7044 if (PyErr_Occurred()) SWIG_fail;
7045 }
7046 resultobj = SWIG_Py_Void();
7047 return resultobj;
7048 fail:
7049 return NULL;
7050 }
7051
7052
7053 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7054 PyObject *resultobj = 0;
7055 wxRect *arg1 = (wxRect *) 0 ;
7056 int arg2 ;
7057 void *argp1 = 0 ;
7058 int res1 = 0 ;
7059 int val2 ;
7060 int ecode2 = 0 ;
7061 PyObject * obj0 = 0 ;
7062 PyObject * obj1 = 0 ;
7063 char * kwnames[] = {
7064 (char *) "self",(char *) "bottom", NULL
7065 };
7066
7067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7069 if (!SWIG_IsOK(res1)) {
7070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7071 }
7072 arg1 = reinterpret_cast< wxRect * >(argp1);
7073 ecode2 = SWIG_AsVal_int(obj1, &val2);
7074 if (!SWIG_IsOK(ecode2)) {
7075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7076 }
7077 arg2 = static_cast< int >(val2);
7078 {
7079 PyThreadState* __tstate = wxPyBeginAllowThreads();
7080 (arg1)->SetBottom(arg2);
7081 wxPyEndAllowThreads(__tstate);
7082 if (PyErr_Occurred()) SWIG_fail;
7083 }
7084 resultobj = SWIG_Py_Void();
7085 return resultobj;
7086 fail:
7087 return NULL;
7088 }
7089
7090
7091 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7092 PyObject *resultobj = 0;
7093 wxRect *arg1 = (wxRect *) 0 ;
7094 int arg2 ;
7095 int arg3 ;
7096 wxRect *result = 0 ;
7097 void *argp1 = 0 ;
7098 int res1 = 0 ;
7099 int val2 ;
7100 int ecode2 = 0 ;
7101 int val3 ;
7102 int ecode3 = 0 ;
7103 PyObject * obj0 = 0 ;
7104 PyObject * obj1 = 0 ;
7105 PyObject * obj2 = 0 ;
7106 char * kwnames[] = {
7107 (char *) "self",(char *) "dx",(char *) "dy", NULL
7108 };
7109
7110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7112 if (!SWIG_IsOK(res1)) {
7113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7114 }
7115 arg1 = reinterpret_cast< wxRect * >(argp1);
7116 ecode2 = SWIG_AsVal_int(obj1, &val2);
7117 if (!SWIG_IsOK(ecode2)) {
7118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7119 }
7120 arg2 = static_cast< int >(val2);
7121 ecode3 = SWIG_AsVal_int(obj2, &val3);
7122 if (!SWIG_IsOK(ecode3)) {
7123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7124 }
7125 arg3 = static_cast< int >(val3);
7126 {
7127 PyThreadState* __tstate = wxPyBeginAllowThreads();
7128 {
7129 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7130 result = (wxRect *) &_result_ref;
7131 }
7132 wxPyEndAllowThreads(__tstate);
7133 if (PyErr_Occurred()) SWIG_fail;
7134 }
7135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7136 return resultobj;
7137 fail:
7138 return NULL;
7139 }
7140
7141
7142 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7143 PyObject *resultobj = 0;
7144 wxRect *arg1 = (wxRect *) 0 ;
7145 int arg2 ;
7146 int arg3 ;
7147 wxRect *result = 0 ;
7148 void *argp1 = 0 ;
7149 int res1 = 0 ;
7150 int val2 ;
7151 int ecode2 = 0 ;
7152 int val3 ;
7153 int ecode3 = 0 ;
7154 PyObject * obj0 = 0 ;
7155 PyObject * obj1 = 0 ;
7156 PyObject * obj2 = 0 ;
7157 char * kwnames[] = {
7158 (char *) "self",(char *) "dx",(char *) "dy", NULL
7159 };
7160
7161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7163 if (!SWIG_IsOK(res1)) {
7164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7165 }
7166 arg1 = reinterpret_cast< wxRect * >(argp1);
7167 ecode2 = SWIG_AsVal_int(obj1, &val2);
7168 if (!SWIG_IsOK(ecode2)) {
7169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7170 }
7171 arg2 = static_cast< int >(val2);
7172 ecode3 = SWIG_AsVal_int(obj2, &val3);
7173 if (!SWIG_IsOK(ecode3)) {
7174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7175 }
7176 arg3 = static_cast< int >(val3);
7177 {
7178 PyThreadState* __tstate = wxPyBeginAllowThreads();
7179 {
7180 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7181 result = (wxRect *) &_result_ref;
7182 }
7183 wxPyEndAllowThreads(__tstate);
7184 if (PyErr_Occurred()) SWIG_fail;
7185 }
7186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7187 return resultobj;
7188 fail:
7189 return NULL;
7190 }
7191
7192
7193 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7194 PyObject *resultobj = 0;
7195 wxRect *arg1 = (wxRect *) 0 ;
7196 int arg2 ;
7197 int arg3 ;
7198 void *argp1 = 0 ;
7199 int res1 = 0 ;
7200 int val2 ;
7201 int ecode2 = 0 ;
7202 int val3 ;
7203 int ecode3 = 0 ;
7204 PyObject * obj0 = 0 ;
7205 PyObject * obj1 = 0 ;
7206 PyObject * obj2 = 0 ;
7207 char * kwnames[] = {
7208 (char *) "self",(char *) "dx",(char *) "dy", NULL
7209 };
7210
7211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7213 if (!SWIG_IsOK(res1)) {
7214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7215 }
7216 arg1 = reinterpret_cast< wxRect * >(argp1);
7217 ecode2 = SWIG_AsVal_int(obj1, &val2);
7218 if (!SWIG_IsOK(ecode2)) {
7219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7220 }
7221 arg2 = static_cast< int >(val2);
7222 ecode3 = SWIG_AsVal_int(obj2, &val3);
7223 if (!SWIG_IsOK(ecode3)) {
7224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7225 }
7226 arg3 = static_cast< int >(val3);
7227 {
7228 PyThreadState* __tstate = wxPyBeginAllowThreads();
7229 (arg1)->Offset(arg2,arg3);
7230 wxPyEndAllowThreads(__tstate);
7231 if (PyErr_Occurred()) SWIG_fail;
7232 }
7233 resultobj = SWIG_Py_Void();
7234 return resultobj;
7235 fail:
7236 return NULL;
7237 }
7238
7239
7240 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7241 PyObject *resultobj = 0;
7242 wxRect *arg1 = (wxRect *) 0 ;
7243 wxPoint *arg2 = 0 ;
7244 void *argp1 = 0 ;
7245 int res1 = 0 ;
7246 wxPoint temp2 ;
7247 PyObject * obj0 = 0 ;
7248 PyObject * obj1 = 0 ;
7249 char * kwnames[] = {
7250 (char *) "self",(char *) "pt", NULL
7251 };
7252
7253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7255 if (!SWIG_IsOK(res1)) {
7256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7257 }
7258 arg1 = reinterpret_cast< wxRect * >(argp1);
7259 {
7260 arg2 = &temp2;
7261 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7262 }
7263 {
7264 PyThreadState* __tstate = wxPyBeginAllowThreads();
7265 (arg1)->Offset((wxPoint const &)*arg2);
7266 wxPyEndAllowThreads(__tstate);
7267 if (PyErr_Occurred()) SWIG_fail;
7268 }
7269 resultobj = SWIG_Py_Void();
7270 return resultobj;
7271 fail:
7272 return NULL;
7273 }
7274
7275
7276 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7277 PyObject *resultobj = 0;
7278 wxRect *arg1 = (wxRect *) 0 ;
7279 wxRect *arg2 = 0 ;
7280 wxRect result;
7281 void *argp1 = 0 ;
7282 int res1 = 0 ;
7283 wxRect temp2 ;
7284 PyObject * obj0 = 0 ;
7285 PyObject * obj1 = 0 ;
7286 char * kwnames[] = {
7287 (char *) "self",(char *) "rect", NULL
7288 };
7289
7290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7292 if (!SWIG_IsOK(res1)) {
7293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7294 }
7295 arg1 = reinterpret_cast< wxRect * >(argp1);
7296 {
7297 arg2 = &temp2;
7298 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7299 }
7300 {
7301 PyThreadState* __tstate = wxPyBeginAllowThreads();
7302 result = (arg1)->Intersect((wxRect const &)*arg2);
7303 wxPyEndAllowThreads(__tstate);
7304 if (PyErr_Occurred()) SWIG_fail;
7305 }
7306 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7307 return resultobj;
7308 fail:
7309 return NULL;
7310 }
7311
7312
7313 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7314 PyObject *resultobj = 0;
7315 wxRect *arg1 = (wxRect *) 0 ;
7316 wxRect *arg2 = 0 ;
7317 wxRect result;
7318 void *argp1 = 0 ;
7319 int res1 = 0 ;
7320 wxRect temp2 ;
7321 PyObject * obj0 = 0 ;
7322 PyObject * obj1 = 0 ;
7323 char * kwnames[] = {
7324 (char *) "self",(char *) "rect", NULL
7325 };
7326
7327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7329 if (!SWIG_IsOK(res1)) {
7330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7331 }
7332 arg1 = reinterpret_cast< wxRect * >(argp1);
7333 {
7334 arg2 = &temp2;
7335 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7336 }
7337 {
7338 PyThreadState* __tstate = wxPyBeginAllowThreads();
7339 result = (arg1)->Union((wxRect const &)*arg2);
7340 wxPyEndAllowThreads(__tstate);
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7351 PyObject *resultobj = 0;
7352 wxRect *arg1 = (wxRect *) 0 ;
7353 wxRect *arg2 = 0 ;
7354 wxRect result;
7355 void *argp1 = 0 ;
7356 int res1 = 0 ;
7357 wxRect temp2 ;
7358 PyObject * obj0 = 0 ;
7359 PyObject * obj1 = 0 ;
7360 char * kwnames[] = {
7361 (char *) "self",(char *) "rect", NULL
7362 };
7363
7364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7366 if (!SWIG_IsOK(res1)) {
7367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7368 }
7369 arg1 = reinterpret_cast< wxRect * >(argp1);
7370 {
7371 arg2 = &temp2;
7372 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7373 }
7374 {
7375 PyThreadState* __tstate = wxPyBeginAllowThreads();
7376 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7377 wxPyEndAllowThreads(__tstate);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj = 0;
7389 wxRect *arg1 = (wxRect *) 0 ;
7390 wxRect *arg2 = 0 ;
7391 wxRect *result = 0 ;
7392 void *argp1 = 0 ;
7393 int res1 = 0 ;
7394 wxRect temp2 ;
7395 PyObject * obj0 = 0 ;
7396 PyObject * obj1 = 0 ;
7397 char * kwnames[] = {
7398 (char *) "self",(char *) "rect", NULL
7399 };
7400
7401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7403 if (!SWIG_IsOK(res1)) {
7404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7405 }
7406 arg1 = reinterpret_cast< wxRect * >(argp1);
7407 {
7408 arg2 = &temp2;
7409 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7410 }
7411 {
7412 PyThreadState* __tstate = wxPyBeginAllowThreads();
7413 {
7414 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7415 result = (wxRect *) &_result_ref;
7416 }
7417 wxPyEndAllowThreads(__tstate);
7418 if (PyErr_Occurred()) SWIG_fail;
7419 }
7420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7421 return resultobj;
7422 fail:
7423 return NULL;
7424 }
7425
7426
7427 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7428 PyObject *resultobj = 0;
7429 wxRect *arg1 = (wxRect *) 0 ;
7430 PyObject *arg2 = (PyObject *) 0 ;
7431 bool result;
7432 void *argp1 = 0 ;
7433 int res1 = 0 ;
7434 PyObject * obj0 = 0 ;
7435 PyObject * obj1 = 0 ;
7436 char * kwnames[] = {
7437 (char *) "self",(char *) "other", NULL
7438 };
7439
7440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7442 if (!SWIG_IsOK(res1)) {
7443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7444 }
7445 arg1 = reinterpret_cast< wxRect * >(argp1);
7446 arg2 = obj1;
7447 {
7448 result = (bool)wxRect___eq__(arg1,arg2);
7449 if (PyErr_Occurred()) SWIG_fail;
7450 }
7451 {
7452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7453 }
7454 return resultobj;
7455 fail:
7456 return NULL;
7457 }
7458
7459
7460 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7461 PyObject *resultobj = 0;
7462 wxRect *arg1 = (wxRect *) 0 ;
7463 PyObject *arg2 = (PyObject *) 0 ;
7464 bool result;
7465 void *argp1 = 0 ;
7466 int res1 = 0 ;
7467 PyObject * obj0 = 0 ;
7468 PyObject * obj1 = 0 ;
7469 char * kwnames[] = {
7470 (char *) "self",(char *) "other", NULL
7471 };
7472
7473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7475 if (!SWIG_IsOK(res1)) {
7476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7477 }
7478 arg1 = reinterpret_cast< wxRect * >(argp1);
7479 arg2 = obj1;
7480 {
7481 result = (bool)wxRect___ne__(arg1,arg2);
7482 if (PyErr_Occurred()) SWIG_fail;
7483 }
7484 {
7485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7486 }
7487 return resultobj;
7488 fail:
7489 return NULL;
7490 }
7491
7492
7493 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7494 PyObject *resultobj = 0;
7495 wxRect *arg1 = (wxRect *) 0 ;
7496 int arg2 ;
7497 int arg3 ;
7498 bool result;
7499 void *argp1 = 0 ;
7500 int res1 = 0 ;
7501 int val2 ;
7502 int ecode2 = 0 ;
7503 int val3 ;
7504 int ecode3 = 0 ;
7505 PyObject * obj0 = 0 ;
7506 PyObject * obj1 = 0 ;
7507 PyObject * obj2 = 0 ;
7508 char * kwnames[] = {
7509 (char *) "self",(char *) "x",(char *) "y", NULL
7510 };
7511
7512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7514 if (!SWIG_IsOK(res1)) {
7515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7516 }
7517 arg1 = reinterpret_cast< wxRect * >(argp1);
7518 ecode2 = SWIG_AsVal_int(obj1, &val2);
7519 if (!SWIG_IsOK(ecode2)) {
7520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7521 }
7522 arg2 = static_cast< int >(val2);
7523 ecode3 = SWIG_AsVal_int(obj2, &val3);
7524 if (!SWIG_IsOK(ecode3)) {
7525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7526 }
7527 arg3 = static_cast< int >(val3);
7528 {
7529 PyThreadState* __tstate = wxPyBeginAllowThreads();
7530 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7531 wxPyEndAllowThreads(__tstate);
7532 if (PyErr_Occurred()) SWIG_fail;
7533 }
7534 {
7535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7536 }
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7544 PyObject *resultobj = 0;
7545 wxRect *arg1 = (wxRect *) 0 ;
7546 wxPoint *arg2 = 0 ;
7547 bool result;
7548 void *argp1 = 0 ;
7549 int res1 = 0 ;
7550 wxPoint temp2 ;
7551 PyObject * obj0 = 0 ;
7552 PyObject * obj1 = 0 ;
7553 char * kwnames[] = {
7554 (char *) "self",(char *) "pt", NULL
7555 };
7556
7557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7559 if (!SWIG_IsOK(res1)) {
7560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7561 }
7562 arg1 = reinterpret_cast< wxRect * >(argp1);
7563 {
7564 arg2 = &temp2;
7565 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7566 }
7567 {
7568 PyThreadState* __tstate = wxPyBeginAllowThreads();
7569 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7570 wxPyEndAllowThreads(__tstate);
7571 if (PyErr_Occurred()) SWIG_fail;
7572 }
7573 {
7574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7575 }
7576 return resultobj;
7577 fail:
7578 return NULL;
7579 }
7580
7581
7582 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7583 PyObject *resultobj = 0;
7584 wxRect *arg1 = (wxRect *) 0 ;
7585 wxRect *arg2 = 0 ;
7586 bool result;
7587 void *argp1 = 0 ;
7588 int res1 = 0 ;
7589 wxRect temp2 ;
7590 PyObject * obj0 = 0 ;
7591 PyObject * obj1 = 0 ;
7592 char * kwnames[] = {
7593 (char *) "self",(char *) "rect", NULL
7594 };
7595
7596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7598 if (!SWIG_IsOK(res1)) {
7599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7600 }
7601 arg1 = reinterpret_cast< wxRect * >(argp1);
7602 {
7603 arg2 = &temp2;
7604 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7605 }
7606 {
7607 PyThreadState* __tstate = wxPyBeginAllowThreads();
7608 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7609 wxPyEndAllowThreads(__tstate);
7610 if (PyErr_Occurred()) SWIG_fail;
7611 }
7612 {
7613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7614 }
7615 return resultobj;
7616 fail:
7617 return NULL;
7618 }
7619
7620
7621 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7622 PyObject *resultobj = 0;
7623 wxRect *arg1 = (wxRect *) 0 ;
7624 wxRect *arg2 = 0 ;
7625 bool result;
7626 void *argp1 = 0 ;
7627 int res1 = 0 ;
7628 wxRect temp2 ;
7629 PyObject * obj0 = 0 ;
7630 PyObject * obj1 = 0 ;
7631 char * kwnames[] = {
7632 (char *) "self",(char *) "rect", NULL
7633 };
7634
7635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7637 if (!SWIG_IsOK(res1)) {
7638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7639 }
7640 arg1 = reinterpret_cast< wxRect * >(argp1);
7641 {
7642 arg2 = &temp2;
7643 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7644 }
7645 {
7646 PyThreadState* __tstate = wxPyBeginAllowThreads();
7647 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7648 wxPyEndAllowThreads(__tstate);
7649 if (PyErr_Occurred()) SWIG_fail;
7650 }
7651 {
7652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7653 }
7654 return resultobj;
7655 fail:
7656 return NULL;
7657 }
7658
7659
7660 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7661 PyObject *resultobj = 0;
7662 wxRect *arg1 = (wxRect *) 0 ;
7663 wxRect *arg2 = 0 ;
7664 int arg3 = (int) wxBOTH ;
7665 wxRect result;
7666 void *argp1 = 0 ;
7667 int res1 = 0 ;
7668 wxRect temp2 ;
7669 int val3 ;
7670 int ecode3 = 0 ;
7671 PyObject * obj0 = 0 ;
7672 PyObject * obj1 = 0 ;
7673 PyObject * obj2 = 0 ;
7674 char * kwnames[] = {
7675 (char *) "self",(char *) "r",(char *) "dir", NULL
7676 };
7677
7678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7680 if (!SWIG_IsOK(res1)) {
7681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7682 }
7683 arg1 = reinterpret_cast< wxRect * >(argp1);
7684 {
7685 arg2 = &temp2;
7686 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7687 }
7688 if (obj2) {
7689 ecode3 = SWIG_AsVal_int(obj2, &val3);
7690 if (!SWIG_IsOK(ecode3)) {
7691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7692 }
7693 arg3 = static_cast< int >(val3);
7694 }
7695 {
7696 PyThreadState* __tstate = wxPyBeginAllowThreads();
7697 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7698 wxPyEndAllowThreads(__tstate);
7699 if (PyErr_Occurred()) SWIG_fail;
7700 }
7701 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7709 PyObject *resultobj = 0;
7710 wxRect *arg1 = (wxRect *) 0 ;
7711 int arg2 ;
7712 void *argp1 = 0 ;
7713 int res1 = 0 ;
7714 int val2 ;
7715 int ecode2 = 0 ;
7716 PyObject *swig_obj[2] ;
7717
7718 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7720 if (!SWIG_IsOK(res1)) {
7721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7722 }
7723 arg1 = reinterpret_cast< wxRect * >(argp1);
7724 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7725 if (!SWIG_IsOK(ecode2)) {
7726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7727 }
7728 arg2 = static_cast< int >(val2);
7729 if (arg1) (arg1)->x = arg2;
7730
7731 resultobj = SWIG_Py_Void();
7732 return resultobj;
7733 fail:
7734 return NULL;
7735 }
7736
7737
7738 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7739 PyObject *resultobj = 0;
7740 wxRect *arg1 = (wxRect *) 0 ;
7741 int result;
7742 void *argp1 = 0 ;
7743 int res1 = 0 ;
7744 PyObject *swig_obj[1] ;
7745
7746 if (!args) SWIG_fail;
7747 swig_obj[0] = args;
7748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7749 if (!SWIG_IsOK(res1)) {
7750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7751 }
7752 arg1 = reinterpret_cast< wxRect * >(argp1);
7753 result = (int) ((arg1)->x);
7754 resultobj = SWIG_From_int(static_cast< int >(result));
7755 return resultobj;
7756 fail:
7757 return NULL;
7758 }
7759
7760
7761 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7762 PyObject *resultobj = 0;
7763 wxRect *arg1 = (wxRect *) 0 ;
7764 int arg2 ;
7765 void *argp1 = 0 ;
7766 int res1 = 0 ;
7767 int val2 ;
7768 int ecode2 = 0 ;
7769 PyObject *swig_obj[2] ;
7770
7771 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7773 if (!SWIG_IsOK(res1)) {
7774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7775 }
7776 arg1 = reinterpret_cast< wxRect * >(argp1);
7777 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7778 if (!SWIG_IsOK(ecode2)) {
7779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7780 }
7781 arg2 = static_cast< int >(val2);
7782 if (arg1) (arg1)->y = arg2;
7783
7784 resultobj = SWIG_Py_Void();
7785 return resultobj;
7786 fail:
7787 return NULL;
7788 }
7789
7790
7791 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7792 PyObject *resultobj = 0;
7793 wxRect *arg1 = (wxRect *) 0 ;
7794 int result;
7795 void *argp1 = 0 ;
7796 int res1 = 0 ;
7797 PyObject *swig_obj[1] ;
7798
7799 if (!args) SWIG_fail;
7800 swig_obj[0] = args;
7801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7802 if (!SWIG_IsOK(res1)) {
7803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7804 }
7805 arg1 = reinterpret_cast< wxRect * >(argp1);
7806 result = (int) ((arg1)->y);
7807 resultobj = SWIG_From_int(static_cast< int >(result));
7808 return resultobj;
7809 fail:
7810 return NULL;
7811 }
7812
7813
7814 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7815 PyObject *resultobj = 0;
7816 wxRect *arg1 = (wxRect *) 0 ;
7817 int arg2 ;
7818 void *argp1 = 0 ;
7819 int res1 = 0 ;
7820 int val2 ;
7821 int ecode2 = 0 ;
7822 PyObject *swig_obj[2] ;
7823
7824 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7826 if (!SWIG_IsOK(res1)) {
7827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7828 }
7829 arg1 = reinterpret_cast< wxRect * >(argp1);
7830 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7831 if (!SWIG_IsOK(ecode2)) {
7832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7833 }
7834 arg2 = static_cast< int >(val2);
7835 if (arg1) (arg1)->width = arg2;
7836
7837 resultobj = SWIG_Py_Void();
7838 return resultobj;
7839 fail:
7840 return NULL;
7841 }
7842
7843
7844 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7845 PyObject *resultobj = 0;
7846 wxRect *arg1 = (wxRect *) 0 ;
7847 int result;
7848 void *argp1 = 0 ;
7849 int res1 = 0 ;
7850 PyObject *swig_obj[1] ;
7851
7852 if (!args) SWIG_fail;
7853 swig_obj[0] = args;
7854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7855 if (!SWIG_IsOK(res1)) {
7856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7857 }
7858 arg1 = reinterpret_cast< wxRect * >(argp1);
7859 result = (int) ((arg1)->width);
7860 resultobj = SWIG_From_int(static_cast< int >(result));
7861 return resultobj;
7862 fail:
7863 return NULL;
7864 }
7865
7866
7867 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7868 PyObject *resultobj = 0;
7869 wxRect *arg1 = (wxRect *) 0 ;
7870 int arg2 ;
7871 void *argp1 = 0 ;
7872 int res1 = 0 ;
7873 int val2 ;
7874 int ecode2 = 0 ;
7875 PyObject *swig_obj[2] ;
7876
7877 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7879 if (!SWIG_IsOK(res1)) {
7880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7881 }
7882 arg1 = reinterpret_cast< wxRect * >(argp1);
7883 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7884 if (!SWIG_IsOK(ecode2)) {
7885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7886 }
7887 arg2 = static_cast< int >(val2);
7888 if (arg1) (arg1)->height = arg2;
7889
7890 resultobj = SWIG_Py_Void();
7891 return resultobj;
7892 fail:
7893 return NULL;
7894 }
7895
7896
7897 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7898 PyObject *resultobj = 0;
7899 wxRect *arg1 = (wxRect *) 0 ;
7900 int result;
7901 void *argp1 = 0 ;
7902 int res1 = 0 ;
7903 PyObject *swig_obj[1] ;
7904
7905 if (!args) SWIG_fail;
7906 swig_obj[0] = args;
7907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7908 if (!SWIG_IsOK(res1)) {
7909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7910 }
7911 arg1 = reinterpret_cast< wxRect * >(argp1);
7912 result = (int) ((arg1)->height);
7913 resultobj = SWIG_From_int(static_cast< int >(result));
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7921 PyObject *resultobj = 0;
7922 wxRect *arg1 = (wxRect *) 0 ;
7923 int arg2 = (int) 0 ;
7924 int arg3 = (int) 0 ;
7925 int arg4 = (int) 0 ;
7926 int arg5 = (int) 0 ;
7927 void *argp1 = 0 ;
7928 int res1 = 0 ;
7929 int val2 ;
7930 int ecode2 = 0 ;
7931 int val3 ;
7932 int ecode3 = 0 ;
7933 int val4 ;
7934 int ecode4 = 0 ;
7935 int val5 ;
7936 int ecode5 = 0 ;
7937 PyObject * obj0 = 0 ;
7938 PyObject * obj1 = 0 ;
7939 PyObject * obj2 = 0 ;
7940 PyObject * obj3 = 0 ;
7941 PyObject * obj4 = 0 ;
7942 char * kwnames[] = {
7943 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7944 };
7945
7946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7948 if (!SWIG_IsOK(res1)) {
7949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7950 }
7951 arg1 = reinterpret_cast< wxRect * >(argp1);
7952 if (obj1) {
7953 ecode2 = SWIG_AsVal_int(obj1, &val2);
7954 if (!SWIG_IsOK(ecode2)) {
7955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7956 }
7957 arg2 = static_cast< int >(val2);
7958 }
7959 if (obj2) {
7960 ecode3 = SWIG_AsVal_int(obj2, &val3);
7961 if (!SWIG_IsOK(ecode3)) {
7962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7963 }
7964 arg3 = static_cast< int >(val3);
7965 }
7966 if (obj3) {
7967 ecode4 = SWIG_AsVal_int(obj3, &val4);
7968 if (!SWIG_IsOK(ecode4)) {
7969 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7970 }
7971 arg4 = static_cast< int >(val4);
7972 }
7973 if (obj4) {
7974 ecode5 = SWIG_AsVal_int(obj4, &val5);
7975 if (!SWIG_IsOK(ecode5)) {
7976 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7977 }
7978 arg5 = static_cast< int >(val5);
7979 }
7980 {
7981 PyThreadState* __tstate = wxPyBeginAllowThreads();
7982 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7983 wxPyEndAllowThreads(__tstate);
7984 if (PyErr_Occurred()) SWIG_fail;
7985 }
7986 resultobj = SWIG_Py_Void();
7987 return resultobj;
7988 fail:
7989 return NULL;
7990 }
7991
7992
7993 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7994 PyObject *resultobj = 0;
7995 wxRect *arg1 = (wxRect *) 0 ;
7996 PyObject *result = 0 ;
7997 void *argp1 = 0 ;
7998 int res1 = 0 ;
7999 PyObject *swig_obj[1] ;
8000
8001 if (!args) SWIG_fail;
8002 swig_obj[0] = args;
8003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8004 if (!SWIG_IsOK(res1)) {
8005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8006 }
8007 arg1 = reinterpret_cast< wxRect * >(argp1);
8008 {
8009 PyThreadState* __tstate = wxPyBeginAllowThreads();
8010 result = (PyObject *)wxRect_Get(arg1);
8011 wxPyEndAllowThreads(__tstate);
8012 if (PyErr_Occurred()) SWIG_fail;
8013 }
8014 resultobj = result;
8015 return resultobj;
8016 fail:
8017 return NULL;
8018 }
8019
8020
8021 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8022 PyObject *obj;
8023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8024 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8025 return SWIG_Py_Void();
8026 }
8027
8028 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8029 return SWIG_Python_InitShadowInstance(args);
8030 }
8031
8032 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8033 PyObject *resultobj = 0;
8034 wxRect *arg1 = (wxRect *) 0 ;
8035 wxRect *arg2 = (wxRect *) 0 ;
8036 PyObject *result = 0 ;
8037 void *argp1 = 0 ;
8038 int res1 = 0 ;
8039 void *argp2 = 0 ;
8040 int res2 = 0 ;
8041 PyObject * obj0 = 0 ;
8042 PyObject * obj1 = 0 ;
8043 char * kwnames[] = {
8044 (char *) "r1",(char *) "r2", NULL
8045 };
8046
8047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8049 if (!SWIG_IsOK(res1)) {
8050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8051 }
8052 arg1 = reinterpret_cast< wxRect * >(argp1);
8053 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8054 if (!SWIG_IsOK(res2)) {
8055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8056 }
8057 arg2 = reinterpret_cast< wxRect * >(argp2);
8058 {
8059 if (!wxPyCheckForApp()) SWIG_fail;
8060 PyThreadState* __tstate = wxPyBeginAllowThreads();
8061 result = (PyObject *)wxIntersectRect(arg1,arg2);
8062 wxPyEndAllowThreads(__tstate);
8063 if (PyErr_Occurred()) SWIG_fail;
8064 }
8065 resultobj = result;
8066 return resultobj;
8067 fail:
8068 return NULL;
8069 }
8070
8071
8072 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8073 PyObject *resultobj = 0;
8074 double arg1 = (double) 0.0 ;
8075 double arg2 = (double) 0.0 ;
8076 wxPoint2D *result = 0 ;
8077 double val1 ;
8078 int ecode1 = 0 ;
8079 double val2 ;
8080 int ecode2 = 0 ;
8081 PyObject * obj0 = 0 ;
8082 PyObject * obj1 = 0 ;
8083 char * kwnames[] = {
8084 (char *) "x",(char *) "y", NULL
8085 };
8086
8087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8088 if (obj0) {
8089 ecode1 = SWIG_AsVal_double(obj0, &val1);
8090 if (!SWIG_IsOK(ecode1)) {
8091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8092 }
8093 arg1 = static_cast< double >(val1);
8094 }
8095 if (obj1) {
8096 ecode2 = SWIG_AsVal_double(obj1, &val2);
8097 if (!SWIG_IsOK(ecode2)) {
8098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8099 }
8100 arg2 = static_cast< double >(val2);
8101 }
8102 {
8103 PyThreadState* __tstate = wxPyBeginAllowThreads();
8104 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8105 wxPyEndAllowThreads(__tstate);
8106 if (PyErr_Occurred()) SWIG_fail;
8107 }
8108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8109 return resultobj;
8110 fail:
8111 return NULL;
8112 }
8113
8114
8115 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8116 PyObject *resultobj = 0;
8117 wxPoint2D *arg1 = 0 ;
8118 wxPoint2D *result = 0 ;
8119 wxPoint2D temp1 ;
8120 PyObject * obj0 = 0 ;
8121 char * kwnames[] = {
8122 (char *) "pt", NULL
8123 };
8124
8125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8126 {
8127 arg1 = &temp1;
8128 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8129 }
8130 {
8131 PyThreadState* __tstate = wxPyBeginAllowThreads();
8132 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8133 wxPyEndAllowThreads(__tstate);
8134 if (PyErr_Occurred()) SWIG_fail;
8135 }
8136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8137 return resultobj;
8138 fail:
8139 return NULL;
8140 }
8141
8142
8143 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8144 PyObject *resultobj = 0;
8145 wxPoint *arg1 = 0 ;
8146 wxPoint2D *result = 0 ;
8147 wxPoint temp1 ;
8148 PyObject * obj0 = 0 ;
8149 char * kwnames[] = {
8150 (char *) "pt", NULL
8151 };
8152
8153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8154 {
8155 arg1 = &temp1;
8156 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8157 }
8158 {
8159 PyThreadState* __tstate = wxPyBeginAllowThreads();
8160 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8161 wxPyEndAllowThreads(__tstate);
8162 if (PyErr_Occurred()) SWIG_fail;
8163 }
8164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8165 return resultobj;
8166 fail:
8167 return NULL;
8168 }
8169
8170
8171 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8172 PyObject *resultobj = 0;
8173 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8174 int *arg2 = (int *) 0 ;
8175 int *arg3 = (int *) 0 ;
8176 void *argp1 = 0 ;
8177 int res1 = 0 ;
8178 int temp2 ;
8179 int res2 = SWIG_TMPOBJ ;
8180 int temp3 ;
8181 int res3 = SWIG_TMPOBJ ;
8182 PyObject *swig_obj[1] ;
8183
8184 arg2 = &temp2;
8185 arg3 = &temp3;
8186 if (!args) SWIG_fail;
8187 swig_obj[0] = args;
8188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8189 if (!SWIG_IsOK(res1)) {
8190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8191 }
8192 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8193 {
8194 PyThreadState* __tstate = wxPyBeginAllowThreads();
8195 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8196 wxPyEndAllowThreads(__tstate);
8197 if (PyErr_Occurred()) SWIG_fail;
8198 }
8199 resultobj = SWIG_Py_Void();
8200 if (SWIG_IsTmpObj(res2)) {
8201 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8202 } else {
8203 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8204 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8205 }
8206 if (SWIG_IsTmpObj(res3)) {
8207 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8208 } else {
8209 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8210 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8211 }
8212 return resultobj;
8213 fail:
8214 return NULL;
8215 }
8216
8217
8218 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8219 PyObject *resultobj = 0;
8220 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8221 int *arg2 = (int *) 0 ;
8222 int *arg3 = (int *) 0 ;
8223 void *argp1 = 0 ;
8224 int res1 = 0 ;
8225 int temp2 ;
8226 int res2 = SWIG_TMPOBJ ;
8227 int temp3 ;
8228 int res3 = SWIG_TMPOBJ ;
8229 PyObject *swig_obj[1] ;
8230
8231 arg2 = &temp2;
8232 arg3 = &temp3;
8233 if (!args) SWIG_fail;
8234 swig_obj[0] = args;
8235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8236 if (!SWIG_IsOK(res1)) {
8237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8238 }
8239 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8240 {
8241 PyThreadState* __tstate = wxPyBeginAllowThreads();
8242 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8243 wxPyEndAllowThreads(__tstate);
8244 if (PyErr_Occurred()) SWIG_fail;
8245 }
8246 resultobj = SWIG_Py_Void();
8247 if (SWIG_IsTmpObj(res2)) {
8248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8249 } else {
8250 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8252 }
8253 if (SWIG_IsTmpObj(res3)) {
8254 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8255 } else {
8256 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8257 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8258 }
8259 return resultobj;
8260 fail:
8261 return NULL;
8262 }
8263
8264
8265 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8266 PyObject *resultobj = 0;
8267 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8268 double result;
8269 void *argp1 = 0 ;
8270 int res1 = 0 ;
8271 PyObject *swig_obj[1] ;
8272
8273 if (!args) SWIG_fail;
8274 swig_obj[0] = args;
8275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8276 if (!SWIG_IsOK(res1)) {
8277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8278 }
8279 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8280 {
8281 PyThreadState* __tstate = wxPyBeginAllowThreads();
8282 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8283 wxPyEndAllowThreads(__tstate);
8284 if (PyErr_Occurred()) SWIG_fail;
8285 }
8286 resultobj = SWIG_From_double(static_cast< double >(result));
8287 return resultobj;
8288 fail:
8289 return NULL;
8290 }
8291
8292
8293 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8294 PyObject *resultobj = 0;
8295 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8296 double result;
8297 void *argp1 = 0 ;
8298 int res1 = 0 ;
8299 PyObject *swig_obj[1] ;
8300
8301 if (!args) SWIG_fail;
8302 swig_obj[0] = args;
8303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8304 if (!SWIG_IsOK(res1)) {
8305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8306 }
8307 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8308 {
8309 PyThreadState* __tstate = wxPyBeginAllowThreads();
8310 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8311 wxPyEndAllowThreads(__tstate);
8312 if (PyErr_Occurred()) SWIG_fail;
8313 }
8314 resultobj = SWIG_From_double(static_cast< double >(result));
8315 return resultobj;
8316 fail:
8317 return NULL;
8318 }
8319
8320
8321 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8322 PyObject *resultobj = 0;
8323 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8324 double arg2 ;
8325 void *argp1 = 0 ;
8326 int res1 = 0 ;
8327 double val2 ;
8328 int ecode2 = 0 ;
8329 PyObject * obj0 = 0 ;
8330 PyObject * obj1 = 0 ;
8331 char * kwnames[] = {
8332 (char *) "self",(char *) "length", NULL
8333 };
8334
8335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8337 if (!SWIG_IsOK(res1)) {
8338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8339 }
8340 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8341 ecode2 = SWIG_AsVal_double(obj1, &val2);
8342 if (!SWIG_IsOK(ecode2)) {
8343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8344 }
8345 arg2 = static_cast< double >(val2);
8346 {
8347 PyThreadState* __tstate = wxPyBeginAllowThreads();
8348 (arg1)->SetVectorLength(arg2);
8349 wxPyEndAllowThreads(__tstate);
8350 if (PyErr_Occurred()) SWIG_fail;
8351 }
8352 resultobj = SWIG_Py_Void();
8353 return resultobj;
8354 fail:
8355 return NULL;
8356 }
8357
8358
8359 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8360 PyObject *resultobj = 0;
8361 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8362 double arg2 ;
8363 void *argp1 = 0 ;
8364 int res1 = 0 ;
8365 double val2 ;
8366 int ecode2 = 0 ;
8367 PyObject * obj0 = 0 ;
8368 PyObject * obj1 = 0 ;
8369 char * kwnames[] = {
8370 (char *) "self",(char *) "degrees", NULL
8371 };
8372
8373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8375 if (!SWIG_IsOK(res1)) {
8376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8377 }
8378 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8379 ecode2 = SWIG_AsVal_double(obj1, &val2);
8380 if (!SWIG_IsOK(ecode2)) {
8381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8382 }
8383 arg2 = static_cast< double >(val2);
8384 {
8385 PyThreadState* __tstate = wxPyBeginAllowThreads();
8386 (arg1)->SetVectorAngle(arg2);
8387 wxPyEndAllowThreads(__tstate);
8388 if (PyErr_Occurred()) SWIG_fail;
8389 }
8390 resultobj = SWIG_Py_Void();
8391 return resultobj;
8392 fail:
8393 return NULL;
8394 }
8395
8396
8397 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8398 PyObject *resultobj = 0;
8399 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8400 wxPoint2D *arg2 = 0 ;
8401 double result;
8402 void *argp1 = 0 ;
8403 int res1 = 0 ;
8404 wxPoint2D temp2 ;
8405 PyObject * obj0 = 0 ;
8406 PyObject * obj1 = 0 ;
8407 char * kwnames[] = {
8408 (char *) "self",(char *) "pt", NULL
8409 };
8410
8411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8413 if (!SWIG_IsOK(res1)) {
8414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8415 }
8416 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8417 {
8418 arg2 = &temp2;
8419 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8420 }
8421 {
8422 PyThreadState* __tstate = wxPyBeginAllowThreads();
8423 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8424 wxPyEndAllowThreads(__tstate);
8425 if (PyErr_Occurred()) SWIG_fail;
8426 }
8427 resultobj = SWIG_From_double(static_cast< double >(result));
8428 return resultobj;
8429 fail:
8430 return NULL;
8431 }
8432
8433
8434 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8435 PyObject *resultobj = 0;
8436 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8437 wxPoint2D *arg2 = 0 ;
8438 double result;
8439 void *argp1 = 0 ;
8440 int res1 = 0 ;
8441 wxPoint2D temp2 ;
8442 PyObject * obj0 = 0 ;
8443 PyObject * obj1 = 0 ;
8444 char * kwnames[] = {
8445 (char *) "self",(char *) "pt", NULL
8446 };
8447
8448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8450 if (!SWIG_IsOK(res1)) {
8451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8452 }
8453 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8454 {
8455 arg2 = &temp2;
8456 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8457 }
8458 {
8459 PyThreadState* __tstate = wxPyBeginAllowThreads();
8460 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8461 wxPyEndAllowThreads(__tstate);
8462 if (PyErr_Occurred()) SWIG_fail;
8463 }
8464 resultobj = SWIG_From_double(static_cast< double >(result));
8465 return resultobj;
8466 fail:
8467 return NULL;
8468 }
8469
8470
8471 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8472 PyObject *resultobj = 0;
8473 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8474 wxPoint2D *arg2 = 0 ;
8475 double result;
8476 void *argp1 = 0 ;
8477 int res1 = 0 ;
8478 wxPoint2D temp2 ;
8479 PyObject * obj0 = 0 ;
8480 PyObject * obj1 = 0 ;
8481 char * kwnames[] = {
8482 (char *) "self",(char *) "vec", NULL
8483 };
8484
8485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8487 if (!SWIG_IsOK(res1)) {
8488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8489 }
8490 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8491 {
8492 arg2 = &temp2;
8493 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8494 }
8495 {
8496 PyThreadState* __tstate = wxPyBeginAllowThreads();
8497 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8498 wxPyEndAllowThreads(__tstate);
8499 if (PyErr_Occurred()) SWIG_fail;
8500 }
8501 resultobj = SWIG_From_double(static_cast< double >(result));
8502 return resultobj;
8503 fail:
8504 return NULL;
8505 }
8506
8507
8508 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8509 PyObject *resultobj = 0;
8510 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8511 wxPoint2D *arg2 = 0 ;
8512 double result;
8513 void *argp1 = 0 ;
8514 int res1 = 0 ;
8515 wxPoint2D temp2 ;
8516 PyObject * obj0 = 0 ;
8517 PyObject * obj1 = 0 ;
8518 char * kwnames[] = {
8519 (char *) "self",(char *) "vec", NULL
8520 };
8521
8522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8524 if (!SWIG_IsOK(res1)) {
8525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8526 }
8527 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8528 {
8529 arg2 = &temp2;
8530 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8531 }
8532 {
8533 PyThreadState* __tstate = wxPyBeginAllowThreads();
8534 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8535 wxPyEndAllowThreads(__tstate);
8536 if (PyErr_Occurred()) SWIG_fail;
8537 }
8538 resultobj = SWIG_From_double(static_cast< double >(result));
8539 return resultobj;
8540 fail:
8541 return NULL;
8542 }
8543
8544
8545 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8546 PyObject *resultobj = 0;
8547 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8548 wxPoint2D result;
8549 void *argp1 = 0 ;
8550 int res1 = 0 ;
8551 PyObject *swig_obj[1] ;
8552
8553 if (!args) SWIG_fail;
8554 swig_obj[0] = args;
8555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8556 if (!SWIG_IsOK(res1)) {
8557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8558 }
8559 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 result = (arg1)->operator -();
8563 wxPyEndAllowThreads(__tstate);
8564 if (PyErr_Occurred()) SWIG_fail;
8565 }
8566 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8567 return resultobj;
8568 fail:
8569 return NULL;
8570 }
8571
8572
8573 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8574 PyObject *resultobj = 0;
8575 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8576 wxPoint2D *arg2 = 0 ;
8577 wxPoint2D *result = 0 ;
8578 void *argp1 = 0 ;
8579 int res1 = 0 ;
8580 wxPoint2D temp2 ;
8581 PyObject * obj0 = 0 ;
8582 PyObject * obj1 = 0 ;
8583 char * kwnames[] = {
8584 (char *) "self",(char *) "pt", NULL
8585 };
8586
8587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8589 if (!SWIG_IsOK(res1)) {
8590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8591 }
8592 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8593 {
8594 arg2 = &temp2;
8595 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8596 }
8597 {
8598 PyThreadState* __tstate = wxPyBeginAllowThreads();
8599 {
8600 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8601 result = (wxPoint2D *) &_result_ref;
8602 }
8603 wxPyEndAllowThreads(__tstate);
8604 if (PyErr_Occurred()) SWIG_fail;
8605 }
8606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8607 return resultobj;
8608 fail:
8609 return NULL;
8610 }
8611
8612
8613 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8614 PyObject *resultobj = 0;
8615 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8616 wxPoint2D *arg2 = 0 ;
8617 wxPoint2D *result = 0 ;
8618 void *argp1 = 0 ;
8619 int res1 = 0 ;
8620 wxPoint2D temp2 ;
8621 PyObject * obj0 = 0 ;
8622 PyObject * obj1 = 0 ;
8623 char * kwnames[] = {
8624 (char *) "self",(char *) "pt", NULL
8625 };
8626
8627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8629 if (!SWIG_IsOK(res1)) {
8630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8631 }
8632 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8633 {
8634 arg2 = &temp2;
8635 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8636 }
8637 {
8638 PyThreadState* __tstate = wxPyBeginAllowThreads();
8639 {
8640 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8641 result = (wxPoint2D *) &_result_ref;
8642 }
8643 wxPyEndAllowThreads(__tstate);
8644 if (PyErr_Occurred()) SWIG_fail;
8645 }
8646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8647 return resultobj;
8648 fail:
8649 return NULL;
8650 }
8651
8652
8653 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8654 PyObject *resultobj = 0;
8655 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8656 wxPoint2D *arg2 = 0 ;
8657 wxPoint2D *result = 0 ;
8658 void *argp1 = 0 ;
8659 int res1 = 0 ;
8660 wxPoint2D temp2 ;
8661 PyObject * obj0 = 0 ;
8662 PyObject * obj1 = 0 ;
8663 char * kwnames[] = {
8664 (char *) "self",(char *) "pt", NULL
8665 };
8666
8667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8669 if (!SWIG_IsOK(res1)) {
8670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8671 }
8672 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8673 {
8674 arg2 = &temp2;
8675 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8676 }
8677 {
8678 PyThreadState* __tstate = wxPyBeginAllowThreads();
8679 {
8680 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8681 result = (wxPoint2D *) &_result_ref;
8682 }
8683 wxPyEndAllowThreads(__tstate);
8684 if (PyErr_Occurred()) SWIG_fail;
8685 }
8686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8687 return resultobj;
8688 fail:
8689 return NULL;
8690 }
8691
8692
8693 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8694 PyObject *resultobj = 0;
8695 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8696 wxPoint2D *arg2 = 0 ;
8697 wxPoint2D *result = 0 ;
8698 void *argp1 = 0 ;
8699 int res1 = 0 ;
8700 wxPoint2D temp2 ;
8701 PyObject * obj0 = 0 ;
8702 PyObject * obj1 = 0 ;
8703 char * kwnames[] = {
8704 (char *) "self",(char *) "pt", NULL
8705 };
8706
8707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8709 if (!SWIG_IsOK(res1)) {
8710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8711 }
8712 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8713 {
8714 arg2 = &temp2;
8715 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8716 }
8717 {
8718 PyThreadState* __tstate = wxPyBeginAllowThreads();
8719 {
8720 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8721 result = (wxPoint2D *) &_result_ref;
8722 }
8723 wxPyEndAllowThreads(__tstate);
8724 if (PyErr_Occurred()) SWIG_fail;
8725 }
8726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8727 return resultobj;
8728 fail:
8729 return NULL;
8730 }
8731
8732
8733 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8734 PyObject *resultobj = 0;
8735 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8736 PyObject *arg2 = (PyObject *) 0 ;
8737 bool result;
8738 void *argp1 = 0 ;
8739 int res1 = 0 ;
8740 PyObject * obj0 = 0 ;
8741 PyObject * obj1 = 0 ;
8742 char * kwnames[] = {
8743 (char *) "self",(char *) "other", NULL
8744 };
8745
8746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8748 if (!SWIG_IsOK(res1)) {
8749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8750 }
8751 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8752 arg2 = obj1;
8753 {
8754 result = (bool)wxPoint2D___eq__(arg1,arg2);
8755 if (PyErr_Occurred()) SWIG_fail;
8756 }
8757 {
8758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8759 }
8760 return resultobj;
8761 fail:
8762 return NULL;
8763 }
8764
8765
8766 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8767 PyObject *resultobj = 0;
8768 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8769 PyObject *arg2 = (PyObject *) 0 ;
8770 bool result;
8771 void *argp1 = 0 ;
8772 int res1 = 0 ;
8773 PyObject * obj0 = 0 ;
8774 PyObject * obj1 = 0 ;
8775 char * kwnames[] = {
8776 (char *) "self",(char *) "other", NULL
8777 };
8778
8779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8781 if (!SWIG_IsOK(res1)) {
8782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8783 }
8784 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8785 arg2 = obj1;
8786 {
8787 result = (bool)wxPoint2D___ne__(arg1,arg2);
8788 if (PyErr_Occurred()) SWIG_fail;
8789 }
8790 {
8791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8792 }
8793 return resultobj;
8794 fail:
8795 return NULL;
8796 }
8797
8798
8799 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8800 PyObject *resultobj = 0;
8801 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8802 double arg2 ;
8803 void *argp1 = 0 ;
8804 int res1 = 0 ;
8805 double val2 ;
8806 int ecode2 = 0 ;
8807 PyObject *swig_obj[2] ;
8808
8809 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8811 if (!SWIG_IsOK(res1)) {
8812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8813 }
8814 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8815 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8816 if (!SWIG_IsOK(ecode2)) {
8817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8818 }
8819 arg2 = static_cast< double >(val2);
8820 if (arg1) (arg1)->m_x = arg2;
8821
8822 resultobj = SWIG_Py_Void();
8823 return resultobj;
8824 fail:
8825 return NULL;
8826 }
8827
8828
8829 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8830 PyObject *resultobj = 0;
8831 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8832 double result;
8833 void *argp1 = 0 ;
8834 int res1 = 0 ;
8835 PyObject *swig_obj[1] ;
8836
8837 if (!args) SWIG_fail;
8838 swig_obj[0] = args;
8839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8840 if (!SWIG_IsOK(res1)) {
8841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8842 }
8843 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8844 result = (double) ((arg1)->m_x);
8845 resultobj = SWIG_From_double(static_cast< double >(result));
8846 return resultobj;
8847 fail:
8848 return NULL;
8849 }
8850
8851
8852 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8853 PyObject *resultobj = 0;
8854 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8855 double arg2 ;
8856 void *argp1 = 0 ;
8857 int res1 = 0 ;
8858 double val2 ;
8859 int ecode2 = 0 ;
8860 PyObject *swig_obj[2] ;
8861
8862 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8864 if (!SWIG_IsOK(res1)) {
8865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8866 }
8867 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8868 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8869 if (!SWIG_IsOK(ecode2)) {
8870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8871 }
8872 arg2 = static_cast< double >(val2);
8873 if (arg1) (arg1)->m_y = arg2;
8874
8875 resultobj = SWIG_Py_Void();
8876 return resultobj;
8877 fail:
8878 return NULL;
8879 }
8880
8881
8882 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8883 PyObject *resultobj = 0;
8884 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8885 double result;
8886 void *argp1 = 0 ;
8887 int res1 = 0 ;
8888 PyObject *swig_obj[1] ;
8889
8890 if (!args) SWIG_fail;
8891 swig_obj[0] = args;
8892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8893 if (!SWIG_IsOK(res1)) {
8894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8895 }
8896 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8897 result = (double) ((arg1)->m_y);
8898 resultobj = SWIG_From_double(static_cast< double >(result));
8899 return resultobj;
8900 fail:
8901 return NULL;
8902 }
8903
8904
8905 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8906 PyObject *resultobj = 0;
8907 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8908 double arg2 = (double) 0 ;
8909 double arg3 = (double) 0 ;
8910 void *argp1 = 0 ;
8911 int res1 = 0 ;
8912 double val2 ;
8913 int ecode2 = 0 ;
8914 double val3 ;
8915 int ecode3 = 0 ;
8916 PyObject * obj0 = 0 ;
8917 PyObject * obj1 = 0 ;
8918 PyObject * obj2 = 0 ;
8919 char * kwnames[] = {
8920 (char *) "self",(char *) "x",(char *) "y", NULL
8921 };
8922
8923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8925 if (!SWIG_IsOK(res1)) {
8926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8927 }
8928 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8929 if (obj1) {
8930 ecode2 = SWIG_AsVal_double(obj1, &val2);
8931 if (!SWIG_IsOK(ecode2)) {
8932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8933 }
8934 arg2 = static_cast< double >(val2);
8935 }
8936 if (obj2) {
8937 ecode3 = SWIG_AsVal_double(obj2, &val3);
8938 if (!SWIG_IsOK(ecode3)) {
8939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8940 }
8941 arg3 = static_cast< double >(val3);
8942 }
8943 {
8944 PyThreadState* __tstate = wxPyBeginAllowThreads();
8945 wxPoint2D_Set(arg1,arg2,arg3);
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 resultobj = SWIG_Py_Void();
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8957 PyObject *resultobj = 0;
8958 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8959 PyObject *result = 0 ;
8960 void *argp1 = 0 ;
8961 int res1 = 0 ;
8962 PyObject *swig_obj[1] ;
8963
8964 if (!args) SWIG_fail;
8965 swig_obj[0] = args;
8966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8967 if (!SWIG_IsOK(res1)) {
8968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8969 }
8970 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8971 {
8972 PyThreadState* __tstate = wxPyBeginAllowThreads();
8973 result = (PyObject *)wxPoint2D_Get(arg1);
8974 wxPyEndAllowThreads(__tstate);
8975 if (PyErr_Occurred()) SWIG_fail;
8976 }
8977 resultobj = result;
8978 return resultobj;
8979 fail:
8980 return NULL;
8981 }
8982
8983
8984 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8985 PyObject *obj;
8986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8987 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8988 return SWIG_Py_Void();
8989 }
8990
8991 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8992 return SWIG_Python_InitShadowInstance(args);
8993 }
8994
8995 SWIGINTERN int DefaultPosition_set(PyObject *) {
8996 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8997 return 1;
8998 }
8999
9000
9001 SWIGINTERN PyObject *DefaultPosition_get(void) {
9002 PyObject *pyobj = 0;
9003
9004 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9005 return pyobj;
9006 }
9007
9008
9009 SWIGINTERN int DefaultSize_set(PyObject *) {
9010 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9011 return 1;
9012 }
9013
9014
9015 SWIGINTERN PyObject *DefaultSize_get(void) {
9016 PyObject *pyobj = 0;
9017
9018 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9019 return pyobj;
9020 }
9021
9022
9023 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9024 PyObject *resultobj = 0;
9025 PyObject *arg1 = (PyObject *) 0 ;
9026 wxPyInputStream *result = 0 ;
9027 PyObject * obj0 = 0 ;
9028 char * kwnames[] = {
9029 (char *) "p", NULL
9030 };
9031
9032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9033 arg1 = obj0;
9034 {
9035 PyThreadState* __tstate = wxPyBeginAllowThreads();
9036 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9037 wxPyEndAllowThreads(__tstate);
9038 if (PyErr_Occurred()) SWIG_fail;
9039 }
9040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9041 return resultobj;
9042 fail:
9043 return NULL;
9044 }
9045
9046
9047 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9048 PyObject *resultobj = 0;
9049 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9050 void *argp1 = 0 ;
9051 int res1 = 0 ;
9052 PyObject *swig_obj[1] ;
9053
9054 if (!args) SWIG_fail;
9055 swig_obj[0] = args;
9056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9057 if (!SWIG_IsOK(res1)) {
9058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9059 }
9060 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9061 {
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 delete arg1;
9064
9065 wxPyEndAllowThreads(__tstate);
9066 if (PyErr_Occurred()) SWIG_fail;
9067 }
9068 resultobj = SWIG_Py_Void();
9069 return resultobj;
9070 fail:
9071 return NULL;
9072 }
9073
9074
9075 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9076 PyObject *resultobj = 0;
9077 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9078 void *argp1 = 0 ;
9079 int res1 = 0 ;
9080 PyObject *swig_obj[1] ;
9081
9082 if (!args) SWIG_fail;
9083 swig_obj[0] = args;
9084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9085 if (!SWIG_IsOK(res1)) {
9086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9087 }
9088 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9089 {
9090 PyThreadState* __tstate = wxPyBeginAllowThreads();
9091 (arg1)->close();
9092 wxPyEndAllowThreads(__tstate);
9093 if (PyErr_Occurred()) SWIG_fail;
9094 }
9095 resultobj = SWIG_Py_Void();
9096 return resultobj;
9097 fail:
9098 return NULL;
9099 }
9100
9101
9102 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9103 PyObject *resultobj = 0;
9104 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9105 void *argp1 = 0 ;
9106 int res1 = 0 ;
9107 PyObject *swig_obj[1] ;
9108
9109 if (!args) SWIG_fail;
9110 swig_obj[0] = args;
9111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9112 if (!SWIG_IsOK(res1)) {
9113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9114 }
9115 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9116 {
9117 PyThreadState* __tstate = wxPyBeginAllowThreads();
9118 (arg1)->flush();
9119 wxPyEndAllowThreads(__tstate);
9120 if (PyErr_Occurred()) SWIG_fail;
9121 }
9122 resultobj = SWIG_Py_Void();
9123 return resultobj;
9124 fail:
9125 return NULL;
9126 }
9127
9128
9129 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9130 PyObject *resultobj = 0;
9131 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9132 bool result;
9133 void *argp1 = 0 ;
9134 int res1 = 0 ;
9135 PyObject *swig_obj[1] ;
9136
9137 if (!args) SWIG_fail;
9138 swig_obj[0] = args;
9139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9140 if (!SWIG_IsOK(res1)) {
9141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9142 }
9143 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9144 {
9145 PyThreadState* __tstate = wxPyBeginAllowThreads();
9146 result = (bool)(arg1)->eof();
9147 wxPyEndAllowThreads(__tstate);
9148 if (PyErr_Occurred()) SWIG_fail;
9149 }
9150 {
9151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9152 }
9153 return resultobj;
9154 fail:
9155 return NULL;
9156 }
9157
9158
9159 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9160 PyObject *resultobj = 0;
9161 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9162 int arg2 = (int) -1 ;
9163 PyObject *result = 0 ;
9164 void *argp1 = 0 ;
9165 int res1 = 0 ;
9166 int val2 ;
9167 int ecode2 = 0 ;
9168 PyObject * obj0 = 0 ;
9169 PyObject * obj1 = 0 ;
9170 char * kwnames[] = {
9171 (char *) "self",(char *) "size", NULL
9172 };
9173
9174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9176 if (!SWIG_IsOK(res1)) {
9177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9178 }
9179 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9180 if (obj1) {
9181 ecode2 = SWIG_AsVal_int(obj1, &val2);
9182 if (!SWIG_IsOK(ecode2)) {
9183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9184 }
9185 arg2 = static_cast< int >(val2);
9186 }
9187 {
9188 PyThreadState* __tstate = wxPyBeginAllowThreads();
9189 result = (PyObject *)(arg1)->read(arg2);
9190 wxPyEndAllowThreads(__tstate);
9191 if (PyErr_Occurred()) SWIG_fail;
9192 }
9193 resultobj = result;
9194 return resultobj;
9195 fail:
9196 return NULL;
9197 }
9198
9199
9200 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9201 PyObject *resultobj = 0;
9202 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9203 int arg2 = (int) -1 ;
9204 PyObject *result = 0 ;
9205 void *argp1 = 0 ;
9206 int res1 = 0 ;
9207 int val2 ;
9208 int ecode2 = 0 ;
9209 PyObject * obj0 = 0 ;
9210 PyObject * obj1 = 0 ;
9211 char * kwnames[] = {
9212 (char *) "self",(char *) "size", NULL
9213 };
9214
9215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9217 if (!SWIG_IsOK(res1)) {
9218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9219 }
9220 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9221 if (obj1) {
9222 ecode2 = SWIG_AsVal_int(obj1, &val2);
9223 if (!SWIG_IsOK(ecode2)) {
9224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9225 }
9226 arg2 = static_cast< int >(val2);
9227 }
9228 {
9229 PyThreadState* __tstate = wxPyBeginAllowThreads();
9230 result = (PyObject *)(arg1)->readline(arg2);
9231 wxPyEndAllowThreads(__tstate);
9232 if (PyErr_Occurred()) SWIG_fail;
9233 }
9234 resultobj = result;
9235 return resultobj;
9236 fail:
9237 return NULL;
9238 }
9239
9240
9241 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9242 PyObject *resultobj = 0;
9243 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9244 int arg2 = (int) -1 ;
9245 PyObject *result = 0 ;
9246 void *argp1 = 0 ;
9247 int res1 = 0 ;
9248 int val2 ;
9249 int ecode2 = 0 ;
9250 PyObject * obj0 = 0 ;
9251 PyObject * obj1 = 0 ;
9252 char * kwnames[] = {
9253 (char *) "self",(char *) "sizehint", NULL
9254 };
9255
9256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9258 if (!SWIG_IsOK(res1)) {
9259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9260 }
9261 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9262 if (obj1) {
9263 ecode2 = SWIG_AsVal_int(obj1, &val2);
9264 if (!SWIG_IsOK(ecode2)) {
9265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9266 }
9267 arg2 = static_cast< int >(val2);
9268 }
9269 {
9270 PyThreadState* __tstate = wxPyBeginAllowThreads();
9271 result = (PyObject *)(arg1)->readlines(arg2);
9272 wxPyEndAllowThreads(__tstate);
9273 if (PyErr_Occurred()) SWIG_fail;
9274 }
9275 resultobj = result;
9276 return resultobj;
9277 fail:
9278 return NULL;
9279 }
9280
9281
9282 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9283 PyObject *resultobj = 0;
9284 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9285 int arg2 ;
9286 int arg3 = (int) 0 ;
9287 void *argp1 = 0 ;
9288 int res1 = 0 ;
9289 int val2 ;
9290 int ecode2 = 0 ;
9291 int val3 ;
9292 int ecode3 = 0 ;
9293 PyObject * obj0 = 0 ;
9294 PyObject * obj1 = 0 ;
9295 PyObject * obj2 = 0 ;
9296 char * kwnames[] = {
9297 (char *) "self",(char *) "offset",(char *) "whence", NULL
9298 };
9299
9300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9302 if (!SWIG_IsOK(res1)) {
9303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9304 }
9305 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9306 ecode2 = SWIG_AsVal_int(obj1, &val2);
9307 if (!SWIG_IsOK(ecode2)) {
9308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9309 }
9310 arg2 = static_cast< int >(val2);
9311 if (obj2) {
9312 ecode3 = SWIG_AsVal_int(obj2, &val3);
9313 if (!SWIG_IsOK(ecode3)) {
9314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9315 }
9316 arg3 = static_cast< int >(val3);
9317 }
9318 {
9319 PyThreadState* __tstate = wxPyBeginAllowThreads();
9320 (arg1)->seek(arg2,arg3);
9321 wxPyEndAllowThreads(__tstate);
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 resultobj = SWIG_Py_Void();
9325 return resultobj;
9326 fail:
9327 return NULL;
9328 }
9329
9330
9331 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9332 PyObject *resultobj = 0;
9333 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9334 int result;
9335 void *argp1 = 0 ;
9336 int res1 = 0 ;
9337 PyObject *swig_obj[1] ;
9338
9339 if (!args) SWIG_fail;
9340 swig_obj[0] = args;
9341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9342 if (!SWIG_IsOK(res1)) {
9343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9344 }
9345 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9346 {
9347 PyThreadState* __tstate = wxPyBeginAllowThreads();
9348 result = (int)(arg1)->tell();
9349 wxPyEndAllowThreads(__tstate);
9350 if (PyErr_Occurred()) SWIG_fail;
9351 }
9352 resultobj = SWIG_From_int(static_cast< int >(result));
9353 return resultobj;
9354 fail:
9355 return NULL;
9356 }
9357
9358
9359 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9360 PyObject *resultobj = 0;
9361 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9362 char result;
9363 void *argp1 = 0 ;
9364 int res1 = 0 ;
9365 PyObject *swig_obj[1] ;
9366
9367 if (!args) SWIG_fail;
9368 swig_obj[0] = args;
9369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9370 if (!SWIG_IsOK(res1)) {
9371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9372 }
9373 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9374 {
9375 PyThreadState* __tstate = wxPyBeginAllowThreads();
9376 result = (char)(arg1)->Peek();
9377 wxPyEndAllowThreads(__tstate);
9378 if (PyErr_Occurred()) SWIG_fail;
9379 }
9380 resultobj = SWIG_From_char(static_cast< char >(result));
9381 return resultobj;
9382 fail:
9383 return NULL;
9384 }
9385
9386
9387 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9388 PyObject *resultobj = 0;
9389 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9390 char result;
9391 void *argp1 = 0 ;
9392 int res1 = 0 ;
9393 PyObject *swig_obj[1] ;
9394
9395 if (!args) SWIG_fail;
9396 swig_obj[0] = args;
9397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9398 if (!SWIG_IsOK(res1)) {
9399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9400 }
9401 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9402 {
9403 PyThreadState* __tstate = wxPyBeginAllowThreads();
9404 result = (char)(arg1)->GetC();
9405 wxPyEndAllowThreads(__tstate);
9406 if (PyErr_Occurred()) SWIG_fail;
9407 }
9408 resultobj = SWIG_From_char(static_cast< char >(result));
9409 return resultobj;
9410 fail:
9411 return NULL;
9412 }
9413
9414
9415 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9416 PyObject *resultobj = 0;
9417 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9418 size_t result;
9419 void *argp1 = 0 ;
9420 int res1 = 0 ;
9421 PyObject *swig_obj[1] ;
9422
9423 if (!args) SWIG_fail;
9424 swig_obj[0] = args;
9425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9426 if (!SWIG_IsOK(res1)) {
9427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9428 }
9429 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9430 {
9431 PyThreadState* __tstate = wxPyBeginAllowThreads();
9432 result = (size_t)(arg1)->LastRead();
9433 wxPyEndAllowThreads(__tstate);
9434 if (PyErr_Occurred()) SWIG_fail;
9435 }
9436 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9437 return resultobj;
9438 fail:
9439 return NULL;
9440 }
9441
9442
9443 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9444 PyObject *resultobj = 0;
9445 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9446 bool result;
9447 void *argp1 = 0 ;
9448 int res1 = 0 ;
9449 PyObject *swig_obj[1] ;
9450
9451 if (!args) SWIG_fail;
9452 swig_obj[0] = args;
9453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9454 if (!SWIG_IsOK(res1)) {
9455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9456 }
9457 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9458 {
9459 PyThreadState* __tstate = wxPyBeginAllowThreads();
9460 result = (bool)(arg1)->CanRead();
9461 wxPyEndAllowThreads(__tstate);
9462 if (PyErr_Occurred()) SWIG_fail;
9463 }
9464 {
9465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9466 }
9467 return resultobj;
9468 fail:
9469 return NULL;
9470 }
9471
9472
9473 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9474 PyObject *resultobj = 0;
9475 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9476 bool result;
9477 void *argp1 = 0 ;
9478 int res1 = 0 ;
9479 PyObject *swig_obj[1] ;
9480
9481 if (!args) SWIG_fail;
9482 swig_obj[0] = args;
9483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9484 if (!SWIG_IsOK(res1)) {
9485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9486 }
9487 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9488 {
9489 PyThreadState* __tstate = wxPyBeginAllowThreads();
9490 result = (bool)(arg1)->Eof();
9491 wxPyEndAllowThreads(__tstate);
9492 if (PyErr_Occurred()) SWIG_fail;
9493 }
9494 {
9495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9496 }
9497 return resultobj;
9498 fail:
9499 return NULL;
9500 }
9501
9502
9503 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9504 PyObject *resultobj = 0;
9505 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9506 char arg2 ;
9507 bool result;
9508 void *argp1 = 0 ;
9509 int res1 = 0 ;
9510 char val2 ;
9511 int ecode2 = 0 ;
9512 PyObject * obj0 = 0 ;
9513 PyObject * obj1 = 0 ;
9514 char * kwnames[] = {
9515 (char *) "self",(char *) "c", NULL
9516 };
9517
9518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9520 if (!SWIG_IsOK(res1)) {
9521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9522 }
9523 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9524 ecode2 = SWIG_AsVal_char(obj1, &val2);
9525 if (!SWIG_IsOK(ecode2)) {
9526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9527 }
9528 arg2 = static_cast< char >(val2);
9529 {
9530 PyThreadState* __tstate = wxPyBeginAllowThreads();
9531 result = (bool)(arg1)->Ungetch(arg2);
9532 wxPyEndAllowThreads(__tstate);
9533 if (PyErr_Occurred()) SWIG_fail;
9534 }
9535 {
9536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9537 }
9538 return resultobj;
9539 fail:
9540 return NULL;
9541 }
9542
9543
9544 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9545 PyObject *resultobj = 0;
9546 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9547 long arg2 ;
9548 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9549 long result;
9550 void *argp1 = 0 ;
9551 int res1 = 0 ;
9552 long val2 ;
9553 int ecode2 = 0 ;
9554 int val3 ;
9555 int ecode3 = 0 ;
9556 PyObject * obj0 = 0 ;
9557 PyObject * obj1 = 0 ;
9558 PyObject * obj2 = 0 ;
9559 char * kwnames[] = {
9560 (char *) "self",(char *) "pos",(char *) "mode", NULL
9561 };
9562
9563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9565 if (!SWIG_IsOK(res1)) {
9566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9567 }
9568 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9569 ecode2 = SWIG_AsVal_long(obj1, &val2);
9570 if (!SWIG_IsOK(ecode2)) {
9571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9572 }
9573 arg2 = static_cast< long >(val2);
9574 if (obj2) {
9575 ecode3 = SWIG_AsVal_int(obj2, &val3);
9576 if (!SWIG_IsOK(ecode3)) {
9577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9578 }
9579 arg3 = static_cast< wxSeekMode >(val3);
9580 }
9581 {
9582 PyThreadState* __tstate = wxPyBeginAllowThreads();
9583 result = (long)(arg1)->SeekI(arg2,arg3);
9584 wxPyEndAllowThreads(__tstate);
9585 if (PyErr_Occurred()) SWIG_fail;
9586 }
9587 resultobj = SWIG_From_long(static_cast< long >(result));
9588 return resultobj;
9589 fail:
9590 return NULL;
9591 }
9592
9593
9594 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9595 PyObject *resultobj = 0;
9596 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9597 long result;
9598 void *argp1 = 0 ;
9599 int res1 = 0 ;
9600 PyObject *swig_obj[1] ;
9601
9602 if (!args) SWIG_fail;
9603 swig_obj[0] = args;
9604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9605 if (!SWIG_IsOK(res1)) {
9606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9607 }
9608 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9609 {
9610 PyThreadState* __tstate = wxPyBeginAllowThreads();
9611 result = (long)(arg1)->TellI();
9612 wxPyEndAllowThreads(__tstate);
9613 if (PyErr_Occurred()) SWIG_fail;
9614 }
9615 resultobj = SWIG_From_long(static_cast< long >(result));
9616 return resultobj;
9617 fail:
9618 return NULL;
9619 }
9620
9621
9622 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9623 PyObject *obj;
9624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9625 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9626 return SWIG_Py_Void();
9627 }
9628
9629 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9630 return SWIG_Python_InitShadowInstance(args);
9631 }
9632
9633 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9634 PyObject *resultobj = 0;
9635 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9636 PyObject *arg2 = (PyObject *) 0 ;
9637 void *argp1 = 0 ;
9638 int res1 = 0 ;
9639 PyObject * obj0 = 0 ;
9640 PyObject * obj1 = 0 ;
9641 char * kwnames[] = {
9642 (char *) "self",(char *) "obj", NULL
9643 };
9644
9645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9647 if (!SWIG_IsOK(res1)) {
9648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9649 }
9650 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9651 arg2 = obj1;
9652 {
9653 PyThreadState* __tstate = wxPyBeginAllowThreads();
9654 wxOutputStream_write(arg1,arg2);
9655 wxPyEndAllowThreads(__tstate);
9656 if (PyErr_Occurred()) SWIG_fail;
9657 }
9658 resultobj = SWIG_Py_Void();
9659 return resultobj;
9660 fail:
9661 return NULL;
9662 }
9663
9664
9665 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9666 PyObject *resultobj = 0;
9667 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9668 size_t result;
9669 void *argp1 = 0 ;
9670 int res1 = 0 ;
9671 PyObject *swig_obj[1] ;
9672
9673 if (!args) SWIG_fail;
9674 swig_obj[0] = args;
9675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9676 if (!SWIG_IsOK(res1)) {
9677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9678 }
9679 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9680 {
9681 PyThreadState* __tstate = wxPyBeginAllowThreads();
9682 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9683 wxPyEndAllowThreads(__tstate);
9684 if (PyErr_Occurred()) SWIG_fail;
9685 }
9686 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9687 return resultobj;
9688 fail:
9689 return NULL;
9690 }
9691
9692
9693 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9694 PyObject *obj;
9695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9696 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9697 return SWIG_Py_Void();
9698 }
9699
9700 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9701 PyObject *resultobj = 0;
9702 wxInputStream *arg1 = (wxInputStream *) 0 ;
9703 wxString *arg2 = 0 ;
9704 wxString *arg3 = 0 ;
9705 wxString *arg4 = 0 ;
9706 wxDateTime arg5 ;
9707 wxFSFile *result = 0 ;
9708 wxPyInputStream *temp1 ;
9709 bool temp2 = false ;
9710 bool temp3 = false ;
9711 bool temp4 = false ;
9712 void *argp5 ;
9713 int res5 = 0 ;
9714 PyObject * obj0 = 0 ;
9715 PyObject * obj1 = 0 ;
9716 PyObject * obj2 = 0 ;
9717 PyObject * obj3 = 0 ;
9718 PyObject * obj4 = 0 ;
9719 char * kwnames[] = {
9720 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9721 };
9722
9723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9724 {
9725 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9726 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9727 } else {
9728 PyErr_Clear(); // clear the failure of the wxPyConvert above
9729 arg1 = wxPyCBInputStream_create(obj0, true);
9730 if (arg1 == NULL) {
9731 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9732 SWIG_fail;
9733 }
9734 }
9735 }
9736 {
9737 arg2 = wxString_in_helper(obj1);
9738 if (arg2 == NULL) SWIG_fail;
9739 temp2 = true;
9740 }
9741 {
9742 arg3 = wxString_in_helper(obj2);
9743 if (arg3 == NULL) SWIG_fail;
9744 temp3 = true;
9745 }
9746 {
9747 arg4 = wxString_in_helper(obj3);
9748 if (arg4 == NULL) SWIG_fail;
9749 temp4 = true;
9750 }
9751 {
9752 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9753 if (!SWIG_IsOK(res5)) {
9754 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9755 }
9756 if (!argp5) {
9757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9758 } else {
9759 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9760 arg5 = *temp;
9761 if (SWIG_IsNewObj(res5)) delete temp;
9762 }
9763 }
9764 {
9765 PyThreadState* __tstate = wxPyBeginAllowThreads();
9766 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9767 wxPyEndAllowThreads(__tstate);
9768 if (PyErr_Occurred()) SWIG_fail;
9769 }
9770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9771 {
9772 if (temp2)
9773 delete arg2;
9774 }
9775 {
9776 if (temp3)
9777 delete arg3;
9778 }
9779 {
9780 if (temp4)
9781 delete arg4;
9782 }
9783 return resultobj;
9784 fail:
9785 {
9786 if (temp2)
9787 delete arg2;
9788 }
9789 {
9790 if (temp3)
9791 delete arg3;
9792 }
9793 {
9794 if (temp4)
9795 delete arg4;
9796 }
9797 return NULL;
9798 }
9799
9800
9801 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9802 PyObject *resultobj = 0;
9803 wxFSFile *arg1 = (wxFSFile *) 0 ;
9804 void *argp1 = 0 ;
9805 int res1 = 0 ;
9806 PyObject *swig_obj[1] ;
9807
9808 if (!args) SWIG_fail;
9809 swig_obj[0] = args;
9810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9811 if (!SWIG_IsOK(res1)) {
9812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9813 }
9814 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9815 {
9816 PyThreadState* __tstate = wxPyBeginAllowThreads();
9817 delete arg1;
9818
9819 wxPyEndAllowThreads(__tstate);
9820 if (PyErr_Occurred()) SWIG_fail;
9821 }
9822 resultobj = SWIG_Py_Void();
9823 return resultobj;
9824 fail:
9825 return NULL;
9826 }
9827
9828
9829 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9830 PyObject *resultobj = 0;
9831 wxFSFile *arg1 = (wxFSFile *) 0 ;
9832 wxInputStream *result = 0 ;
9833 void *argp1 = 0 ;
9834 int res1 = 0 ;
9835 PyObject *swig_obj[1] ;
9836
9837 if (!args) SWIG_fail;
9838 swig_obj[0] = args;
9839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9840 if (!SWIG_IsOK(res1)) {
9841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9842 }
9843 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9844 {
9845 PyThreadState* __tstate = wxPyBeginAllowThreads();
9846 result = (wxInputStream *)(arg1)->GetStream();
9847 wxPyEndAllowThreads(__tstate);
9848 if (PyErr_Occurred()) SWIG_fail;
9849 }
9850 {
9851 wxPyInputStream * _ptr = NULL;
9852
9853 if (result) {
9854 _ptr = new wxPyInputStream(result);
9855 }
9856 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9857 }
9858 return resultobj;
9859 fail:
9860 return NULL;
9861 }
9862
9863
9864 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9865 PyObject *resultobj = 0;
9866 wxFSFile *arg1 = (wxFSFile *) 0 ;
9867 void *argp1 = 0 ;
9868 int res1 = 0 ;
9869 PyObject *swig_obj[1] ;
9870
9871 if (!args) SWIG_fail;
9872 swig_obj[0] = args;
9873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9874 if (!SWIG_IsOK(res1)) {
9875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9876 }
9877 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9878 {
9879 PyThreadState* __tstate = wxPyBeginAllowThreads();
9880 (arg1)->DetachStream();
9881 wxPyEndAllowThreads(__tstate);
9882 if (PyErr_Occurred()) SWIG_fail;
9883 }
9884 resultobj = SWIG_Py_Void();
9885 return resultobj;
9886 fail:
9887 return NULL;
9888 }
9889
9890
9891 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9892 PyObject *resultobj = 0;
9893 wxFSFile *arg1 = (wxFSFile *) 0 ;
9894 wxString *result = 0 ;
9895 void *argp1 = 0 ;
9896 int res1 = 0 ;
9897 PyObject *swig_obj[1] ;
9898
9899 if (!args) SWIG_fail;
9900 swig_obj[0] = args;
9901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9902 if (!SWIG_IsOK(res1)) {
9903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9904 }
9905 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9906 {
9907 PyThreadState* __tstate = wxPyBeginAllowThreads();
9908 {
9909 wxString const &_result_ref = (arg1)->GetMimeType();
9910 result = (wxString *) &_result_ref;
9911 }
9912 wxPyEndAllowThreads(__tstate);
9913 if (PyErr_Occurred()) SWIG_fail;
9914 }
9915 {
9916 #if wxUSE_UNICODE
9917 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9918 #else
9919 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9920 #endif
9921 }
9922 return resultobj;
9923 fail:
9924 return NULL;
9925 }
9926
9927
9928 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9929 PyObject *resultobj = 0;
9930 wxFSFile *arg1 = (wxFSFile *) 0 ;
9931 wxString *result = 0 ;
9932 void *argp1 = 0 ;
9933 int res1 = 0 ;
9934 PyObject *swig_obj[1] ;
9935
9936 if (!args) SWIG_fail;
9937 swig_obj[0] = args;
9938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9939 if (!SWIG_IsOK(res1)) {
9940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9941 }
9942 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9943 {
9944 PyThreadState* __tstate = wxPyBeginAllowThreads();
9945 {
9946 wxString const &_result_ref = (arg1)->GetLocation();
9947 result = (wxString *) &_result_ref;
9948 }
9949 wxPyEndAllowThreads(__tstate);
9950 if (PyErr_Occurred()) SWIG_fail;
9951 }
9952 {
9953 #if wxUSE_UNICODE
9954 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9955 #else
9956 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9957 #endif
9958 }
9959 return resultobj;
9960 fail:
9961 return NULL;
9962 }
9963
9964
9965 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9966 PyObject *resultobj = 0;
9967 wxFSFile *arg1 = (wxFSFile *) 0 ;
9968 wxString *result = 0 ;
9969 void *argp1 = 0 ;
9970 int res1 = 0 ;
9971 PyObject *swig_obj[1] ;
9972
9973 if (!args) SWIG_fail;
9974 swig_obj[0] = args;
9975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9976 if (!SWIG_IsOK(res1)) {
9977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9978 }
9979 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9980 {
9981 PyThreadState* __tstate = wxPyBeginAllowThreads();
9982 {
9983 wxString const &_result_ref = (arg1)->GetAnchor();
9984 result = (wxString *) &_result_ref;
9985 }
9986 wxPyEndAllowThreads(__tstate);
9987 if (PyErr_Occurred()) SWIG_fail;
9988 }
9989 {
9990 #if wxUSE_UNICODE
9991 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9992 #else
9993 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9994 #endif
9995 }
9996 return resultobj;
9997 fail:
9998 return NULL;
9999 }
10000
10001
10002 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10003 PyObject *resultobj = 0;
10004 wxFSFile *arg1 = (wxFSFile *) 0 ;
10005 wxDateTime result;
10006 void *argp1 = 0 ;
10007 int res1 = 0 ;
10008 PyObject *swig_obj[1] ;
10009
10010 if (!args) SWIG_fail;
10011 swig_obj[0] = args;
10012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10013 if (!SWIG_IsOK(res1)) {
10014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10015 }
10016 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10017 {
10018 PyThreadState* __tstate = wxPyBeginAllowThreads();
10019 result = (arg1)->GetModificationTime();
10020 wxPyEndAllowThreads(__tstate);
10021 if (PyErr_Occurred()) SWIG_fail;
10022 }
10023 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10024 return resultobj;
10025 fail:
10026 return NULL;
10027 }
10028
10029
10030 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10031 PyObject *obj;
10032 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10033 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10034 return SWIG_Py_Void();
10035 }
10036
10037 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10038 return SWIG_Python_InitShadowInstance(args);
10039 }
10040
10041 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10042 PyObject *resultobj = 0;
10043 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10044 void *argp1 = 0 ;
10045 int res1 = 0 ;
10046 PyObject *swig_obj[1] ;
10047
10048 if (!args) SWIG_fail;
10049 swig_obj[0] = args;
10050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10051 if (!SWIG_IsOK(res1)) {
10052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10053 }
10054 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10055 {
10056 PyThreadState* __tstate = wxPyBeginAllowThreads();
10057 delete arg1;
10058
10059 wxPyEndAllowThreads(__tstate);
10060 if (PyErr_Occurred()) SWIG_fail;
10061 }
10062 resultobj = SWIG_Py_Void();
10063 return resultobj;
10064 fail:
10065 return NULL;
10066 }
10067
10068
10069 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10070 PyObject *obj;
10071 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10072 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10073 return SWIG_Py_Void();
10074 }
10075
10076 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10077 PyObject *resultobj = 0;
10078 wxPyFileSystemHandler *result = 0 ;
10079
10080 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10081 {
10082 PyThreadState* __tstate = wxPyBeginAllowThreads();
10083 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10084 wxPyEndAllowThreads(__tstate);
10085 if (PyErr_Occurred()) SWIG_fail;
10086 }
10087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10088 return resultobj;
10089 fail:
10090 return NULL;
10091 }
10092
10093
10094 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10095 PyObject *resultobj = 0;
10096 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10097 PyObject *arg2 = (PyObject *) 0 ;
10098 PyObject *arg3 = (PyObject *) 0 ;
10099 void *argp1 = 0 ;
10100 int res1 = 0 ;
10101 PyObject * obj0 = 0 ;
10102 PyObject * obj1 = 0 ;
10103 PyObject * obj2 = 0 ;
10104 char * kwnames[] = {
10105 (char *) "self",(char *) "self",(char *) "_class", NULL
10106 };
10107
10108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10110 if (!SWIG_IsOK(res1)) {
10111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10112 }
10113 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10114 arg2 = obj1;
10115 arg3 = obj2;
10116 {
10117 PyThreadState* __tstate = wxPyBeginAllowThreads();
10118 (arg1)->_setCallbackInfo(arg2,arg3);
10119 wxPyEndAllowThreads(__tstate);
10120 if (PyErr_Occurred()) SWIG_fail;
10121 }
10122 resultobj = SWIG_Py_Void();
10123 return resultobj;
10124 fail:
10125 return NULL;
10126 }
10127
10128
10129 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10130 PyObject *resultobj = 0;
10131 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10132 wxString *arg2 = 0 ;
10133 bool result;
10134 void *argp1 = 0 ;
10135 int res1 = 0 ;
10136 bool temp2 = false ;
10137 PyObject * obj0 = 0 ;
10138 PyObject * obj1 = 0 ;
10139 char * kwnames[] = {
10140 (char *) "self",(char *) "location", NULL
10141 };
10142
10143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10145 if (!SWIG_IsOK(res1)) {
10146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10147 }
10148 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10149 {
10150 arg2 = wxString_in_helper(obj1);
10151 if (arg2 == NULL) SWIG_fail;
10152 temp2 = true;
10153 }
10154 {
10155 PyThreadState* __tstate = wxPyBeginAllowThreads();
10156 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10157 wxPyEndAllowThreads(__tstate);
10158 if (PyErr_Occurred()) SWIG_fail;
10159 }
10160 {
10161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10162 }
10163 {
10164 if (temp2)
10165 delete arg2;
10166 }
10167 return resultobj;
10168 fail:
10169 {
10170 if (temp2)
10171 delete arg2;
10172 }
10173 return NULL;
10174 }
10175
10176
10177 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10178 PyObject *resultobj = 0;
10179 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10180 wxFileSystem *arg2 = 0 ;
10181 wxString *arg3 = 0 ;
10182 wxFSFile *result = 0 ;
10183 void *argp1 = 0 ;
10184 int res1 = 0 ;
10185 void *argp2 = 0 ;
10186 int res2 = 0 ;
10187 bool temp3 = false ;
10188 PyObject * obj0 = 0 ;
10189 PyObject * obj1 = 0 ;
10190 PyObject * obj2 = 0 ;
10191 char * kwnames[] = {
10192 (char *) "self",(char *) "fs",(char *) "location", NULL
10193 };
10194
10195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10197 if (!SWIG_IsOK(res1)) {
10198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10199 }
10200 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10201 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10202 if (!SWIG_IsOK(res2)) {
10203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10204 }
10205 if (!argp2) {
10206 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10207 }
10208 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10209 {
10210 arg3 = wxString_in_helper(obj2);
10211 if (arg3 == NULL) SWIG_fail;
10212 temp3 = true;
10213 }
10214 {
10215 PyThreadState* __tstate = wxPyBeginAllowThreads();
10216 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10217 wxPyEndAllowThreads(__tstate);
10218 if (PyErr_Occurred()) SWIG_fail;
10219 }
10220 {
10221 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10222 }
10223 {
10224 if (temp3)
10225 delete arg3;
10226 }
10227 return resultobj;
10228 fail:
10229 {
10230 if (temp3)
10231 delete arg3;
10232 }
10233 return NULL;
10234 }
10235
10236
10237 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10238 PyObject *resultobj = 0;
10239 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10240 wxString *arg2 = 0 ;
10241 int arg3 = (int) 0 ;
10242 wxString result;
10243 void *argp1 = 0 ;
10244 int res1 = 0 ;
10245 bool temp2 = false ;
10246 int val3 ;
10247 int ecode3 = 0 ;
10248 PyObject * obj0 = 0 ;
10249 PyObject * obj1 = 0 ;
10250 PyObject * obj2 = 0 ;
10251 char * kwnames[] = {
10252 (char *) "self",(char *) "spec",(char *) "flags", NULL
10253 };
10254
10255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10257 if (!SWIG_IsOK(res1)) {
10258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10259 }
10260 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10261 {
10262 arg2 = wxString_in_helper(obj1);
10263 if (arg2 == NULL) SWIG_fail;
10264 temp2 = true;
10265 }
10266 if (obj2) {
10267 ecode3 = SWIG_AsVal_int(obj2, &val3);
10268 if (!SWIG_IsOK(ecode3)) {
10269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10270 }
10271 arg3 = static_cast< int >(val3);
10272 }
10273 {
10274 PyThreadState* __tstate = wxPyBeginAllowThreads();
10275 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
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_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10301 PyObject *resultobj = 0;
10302 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10303 wxString result;
10304 void *argp1 = 0 ;
10305 int res1 = 0 ;
10306 PyObject *swig_obj[1] ;
10307
10308 if (!args) SWIG_fail;
10309 swig_obj[0] = args;
10310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10311 if (!SWIG_IsOK(res1)) {
10312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10313 }
10314 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10315 {
10316 PyThreadState* __tstate = wxPyBeginAllowThreads();
10317 result = (arg1)->FindNext();
10318 wxPyEndAllowThreads(__tstate);
10319 if (PyErr_Occurred()) SWIG_fail;
10320 }
10321 {
10322 #if wxUSE_UNICODE
10323 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10324 #else
10325 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10326 #endif
10327 }
10328 return resultobj;
10329 fail:
10330 return NULL;
10331 }
10332
10333
10334 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10335 PyObject *resultobj = 0;
10336 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10337 wxString *arg2 = 0 ;
10338 wxString result;
10339 void *argp1 = 0 ;
10340 int res1 = 0 ;
10341 bool temp2 = false ;
10342 PyObject * obj0 = 0 ;
10343 PyObject * obj1 = 0 ;
10344 char * kwnames[] = {
10345 (char *) "self",(char *) "location", NULL
10346 };
10347
10348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10350 if (!SWIG_IsOK(res1)) {
10351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10352 }
10353 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10354 {
10355 arg2 = wxString_in_helper(obj1);
10356 if (arg2 == NULL) SWIG_fail;
10357 temp2 = true;
10358 }
10359 {
10360 PyThreadState* __tstate = wxPyBeginAllowThreads();
10361 result = (arg1)->GetProtocol((wxString const &)*arg2);
10362 wxPyEndAllowThreads(__tstate);
10363 if (PyErr_Occurred()) SWIG_fail;
10364 }
10365 {
10366 #if wxUSE_UNICODE
10367 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10368 #else
10369 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10370 #endif
10371 }
10372 {
10373 if (temp2)
10374 delete arg2;
10375 }
10376 return resultobj;
10377 fail:
10378 {
10379 if (temp2)
10380 delete arg2;
10381 }
10382 return NULL;
10383 }
10384
10385
10386 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10387 PyObject *resultobj = 0;
10388 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10389 wxString *arg2 = 0 ;
10390 wxString result;
10391 void *argp1 = 0 ;
10392 int res1 = 0 ;
10393 bool temp2 = false ;
10394 PyObject * obj0 = 0 ;
10395 PyObject * obj1 = 0 ;
10396 char * kwnames[] = {
10397 (char *) "self",(char *) "location", NULL
10398 };
10399
10400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10402 if (!SWIG_IsOK(res1)) {
10403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10404 }
10405 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10406 {
10407 arg2 = wxString_in_helper(obj1);
10408 if (arg2 == NULL) SWIG_fail;
10409 temp2 = true;
10410 }
10411 {
10412 PyThreadState* __tstate = wxPyBeginAllowThreads();
10413 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10414 wxPyEndAllowThreads(__tstate);
10415 if (PyErr_Occurred()) SWIG_fail;
10416 }
10417 {
10418 #if wxUSE_UNICODE
10419 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10420 #else
10421 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10422 #endif
10423 }
10424 {
10425 if (temp2)
10426 delete arg2;
10427 }
10428 return resultobj;
10429 fail:
10430 {
10431 if (temp2)
10432 delete arg2;
10433 }
10434 return NULL;
10435 }
10436
10437
10438 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10439 PyObject *resultobj = 0;
10440 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10441 wxString *arg2 = 0 ;
10442 wxString result;
10443 void *argp1 = 0 ;
10444 int res1 = 0 ;
10445 bool temp2 = false ;
10446 PyObject * obj0 = 0 ;
10447 PyObject * obj1 = 0 ;
10448 char * kwnames[] = {
10449 (char *) "self",(char *) "location", NULL
10450 };
10451
10452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10454 if (!SWIG_IsOK(res1)) {
10455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10456 }
10457 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10458 {
10459 arg2 = wxString_in_helper(obj1);
10460 if (arg2 == NULL) SWIG_fail;
10461 temp2 = true;
10462 }
10463 {
10464 PyThreadState* __tstate = wxPyBeginAllowThreads();
10465 result = (arg1)->GetAnchor((wxString const &)*arg2);
10466 wxPyEndAllowThreads(__tstate);
10467 if (PyErr_Occurred()) SWIG_fail;
10468 }
10469 {
10470 #if wxUSE_UNICODE
10471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10472 #else
10473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10474 #endif
10475 }
10476 {
10477 if (temp2)
10478 delete arg2;
10479 }
10480 return resultobj;
10481 fail:
10482 {
10483 if (temp2)
10484 delete arg2;
10485 }
10486 return NULL;
10487 }
10488
10489
10490 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10491 PyObject *resultobj = 0;
10492 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10493 wxString *arg2 = 0 ;
10494 wxString result;
10495 void *argp1 = 0 ;
10496 int res1 = 0 ;
10497 bool temp2 = false ;
10498 PyObject * obj0 = 0 ;
10499 PyObject * obj1 = 0 ;
10500 char * kwnames[] = {
10501 (char *) "self",(char *) "location", NULL
10502 };
10503
10504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10506 if (!SWIG_IsOK(res1)) {
10507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10508 }
10509 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10510 {
10511 arg2 = wxString_in_helper(obj1);
10512 if (arg2 == NULL) SWIG_fail;
10513 temp2 = true;
10514 }
10515 {
10516 PyThreadState* __tstate = wxPyBeginAllowThreads();
10517 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10518 wxPyEndAllowThreads(__tstate);
10519 if (PyErr_Occurred()) SWIG_fail;
10520 }
10521 {
10522 #if wxUSE_UNICODE
10523 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10524 #else
10525 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10526 #endif
10527 }
10528 {
10529 if (temp2)
10530 delete arg2;
10531 }
10532 return resultobj;
10533 fail:
10534 {
10535 if (temp2)
10536 delete arg2;
10537 }
10538 return NULL;
10539 }
10540
10541
10542 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10543 PyObject *resultobj = 0;
10544 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10545 wxString *arg2 = 0 ;
10546 wxString result;
10547 void *argp1 = 0 ;
10548 int res1 = 0 ;
10549 bool temp2 = false ;
10550 PyObject * obj0 = 0 ;
10551 PyObject * obj1 = 0 ;
10552 char * kwnames[] = {
10553 (char *) "self",(char *) "location", NULL
10554 };
10555
10556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10558 if (!SWIG_IsOK(res1)) {
10559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10560 }
10561 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10562 {
10563 arg2 = wxString_in_helper(obj1);
10564 if (arg2 == NULL) SWIG_fail;
10565 temp2 = true;
10566 }
10567 {
10568 PyThreadState* __tstate = wxPyBeginAllowThreads();
10569 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10570 wxPyEndAllowThreads(__tstate);
10571 if (PyErr_Occurred()) SWIG_fail;
10572 }
10573 {
10574 #if wxUSE_UNICODE
10575 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10576 #else
10577 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10578 #endif
10579 }
10580 {
10581 if (temp2)
10582 delete arg2;
10583 }
10584 return resultobj;
10585 fail:
10586 {
10587 if (temp2)
10588 delete arg2;
10589 }
10590 return NULL;
10591 }
10592
10593
10594 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10595 PyObject *obj;
10596 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10597 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10598 return SWIG_Py_Void();
10599 }
10600
10601 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10602 return SWIG_Python_InitShadowInstance(args);
10603 }
10604
10605 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10606 PyObject *resultobj = 0;
10607 wxFileSystem *result = 0 ;
10608
10609 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10610 {
10611 PyThreadState* __tstate = wxPyBeginAllowThreads();
10612 result = (wxFileSystem *)new wxFileSystem();
10613 wxPyEndAllowThreads(__tstate);
10614 if (PyErr_Occurred()) SWIG_fail;
10615 }
10616 {
10617 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10618 }
10619 return resultobj;
10620 fail:
10621 return NULL;
10622 }
10623
10624
10625 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10626 PyObject *resultobj = 0;
10627 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10628 void *argp1 = 0 ;
10629 int res1 = 0 ;
10630 PyObject *swig_obj[1] ;
10631
10632 if (!args) SWIG_fail;
10633 swig_obj[0] = args;
10634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10635 if (!SWIG_IsOK(res1)) {
10636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10637 }
10638 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10639 {
10640 PyThreadState* __tstate = wxPyBeginAllowThreads();
10641 delete arg1;
10642
10643 wxPyEndAllowThreads(__tstate);
10644 if (PyErr_Occurred()) SWIG_fail;
10645 }
10646 resultobj = SWIG_Py_Void();
10647 return resultobj;
10648 fail:
10649 return NULL;
10650 }
10651
10652
10653 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10654 PyObject *resultobj = 0;
10655 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10656 wxString *arg2 = 0 ;
10657 bool arg3 = (bool) false ;
10658 void *argp1 = 0 ;
10659 int res1 = 0 ;
10660 bool temp2 = false ;
10661 bool val3 ;
10662 int ecode3 = 0 ;
10663 PyObject * obj0 = 0 ;
10664 PyObject * obj1 = 0 ;
10665 PyObject * obj2 = 0 ;
10666 char * kwnames[] = {
10667 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10668 };
10669
10670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10672 if (!SWIG_IsOK(res1)) {
10673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10674 }
10675 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10676 {
10677 arg2 = wxString_in_helper(obj1);
10678 if (arg2 == NULL) SWIG_fail;
10679 temp2 = true;
10680 }
10681 if (obj2) {
10682 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10683 if (!SWIG_IsOK(ecode3)) {
10684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10685 }
10686 arg3 = static_cast< bool >(val3);
10687 }
10688 {
10689 PyThreadState* __tstate = wxPyBeginAllowThreads();
10690 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10691 wxPyEndAllowThreads(__tstate);
10692 if (PyErr_Occurred()) SWIG_fail;
10693 }
10694 resultobj = SWIG_Py_Void();
10695 {
10696 if (temp2)
10697 delete arg2;
10698 }
10699 return resultobj;
10700 fail:
10701 {
10702 if (temp2)
10703 delete arg2;
10704 }
10705 return NULL;
10706 }
10707
10708
10709 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10710 PyObject *resultobj = 0;
10711 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10712 wxString result;
10713 void *argp1 = 0 ;
10714 int res1 = 0 ;
10715 PyObject *swig_obj[1] ;
10716
10717 if (!args) SWIG_fail;
10718 swig_obj[0] = args;
10719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10720 if (!SWIG_IsOK(res1)) {
10721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10722 }
10723 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10724 {
10725 PyThreadState* __tstate = wxPyBeginAllowThreads();
10726 result = (arg1)->GetPath();
10727 wxPyEndAllowThreads(__tstate);
10728 if (PyErr_Occurred()) SWIG_fail;
10729 }
10730 {
10731 #if wxUSE_UNICODE
10732 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10733 #else
10734 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10735 #endif
10736 }
10737 return resultobj;
10738 fail:
10739 return NULL;
10740 }
10741
10742
10743 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10744 PyObject *resultobj = 0;
10745 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10746 wxString *arg2 = 0 ;
10747 wxFSFile *result = 0 ;
10748 void *argp1 = 0 ;
10749 int res1 = 0 ;
10750 bool temp2 = false ;
10751 PyObject * obj0 = 0 ;
10752 PyObject * obj1 = 0 ;
10753 char * kwnames[] = {
10754 (char *) "self",(char *) "location", NULL
10755 };
10756
10757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10759 if (!SWIG_IsOK(res1)) {
10760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10761 }
10762 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10763 {
10764 arg2 = wxString_in_helper(obj1);
10765 if (arg2 == NULL) SWIG_fail;
10766 temp2 = true;
10767 }
10768 {
10769 PyThreadState* __tstate = wxPyBeginAllowThreads();
10770 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10771 wxPyEndAllowThreads(__tstate);
10772 if (PyErr_Occurred()) SWIG_fail;
10773 }
10774 {
10775 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10776 }
10777 {
10778 if (temp2)
10779 delete arg2;
10780 }
10781 return resultobj;
10782 fail:
10783 {
10784 if (temp2)
10785 delete arg2;
10786 }
10787 return NULL;
10788 }
10789
10790
10791 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10792 PyObject *resultobj = 0;
10793 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10794 wxString *arg2 = 0 ;
10795 int arg3 = (int) 0 ;
10796 wxString result;
10797 void *argp1 = 0 ;
10798 int res1 = 0 ;
10799 bool temp2 = false ;
10800 int val3 ;
10801 int ecode3 = 0 ;
10802 PyObject * obj0 = 0 ;
10803 PyObject * obj1 = 0 ;
10804 PyObject * obj2 = 0 ;
10805 char * kwnames[] = {
10806 (char *) "self",(char *) "spec",(char *) "flags", NULL
10807 };
10808
10809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10811 if (!SWIG_IsOK(res1)) {
10812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10813 }
10814 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10815 {
10816 arg2 = wxString_in_helper(obj1);
10817 if (arg2 == NULL) SWIG_fail;
10818 temp2 = true;
10819 }
10820 if (obj2) {
10821 ecode3 = SWIG_AsVal_int(obj2, &val3);
10822 if (!SWIG_IsOK(ecode3)) {
10823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10824 }
10825 arg3 = static_cast< int >(val3);
10826 }
10827 {
10828 PyThreadState* __tstate = wxPyBeginAllowThreads();
10829 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10830 wxPyEndAllowThreads(__tstate);
10831 if (PyErr_Occurred()) SWIG_fail;
10832 }
10833 {
10834 #if wxUSE_UNICODE
10835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10836 #else
10837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10838 #endif
10839 }
10840 {
10841 if (temp2)
10842 delete arg2;
10843 }
10844 return resultobj;
10845 fail:
10846 {
10847 if (temp2)
10848 delete arg2;
10849 }
10850 return NULL;
10851 }
10852
10853
10854 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10855 PyObject *resultobj = 0;
10856 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10857 wxString result;
10858 void *argp1 = 0 ;
10859 int res1 = 0 ;
10860 PyObject *swig_obj[1] ;
10861
10862 if (!args) SWIG_fail;
10863 swig_obj[0] = args;
10864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10865 if (!SWIG_IsOK(res1)) {
10866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10867 }
10868 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10869 {
10870 PyThreadState* __tstate = wxPyBeginAllowThreads();
10871 result = (arg1)->FindNext();
10872 wxPyEndAllowThreads(__tstate);
10873 if (PyErr_Occurred()) SWIG_fail;
10874 }
10875 {
10876 #if wxUSE_UNICODE
10877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10878 #else
10879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10880 #endif
10881 }
10882 return resultobj;
10883 fail:
10884 return NULL;
10885 }
10886
10887
10888 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10889 PyObject *resultobj = 0;
10890 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10891 int res1 = 0 ;
10892 PyObject * obj0 = 0 ;
10893 char * kwnames[] = {
10894 (char *) "handler", NULL
10895 };
10896
10897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10898 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10899 if (!SWIG_IsOK(res1)) {
10900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10901 }
10902 {
10903 PyThreadState* __tstate = wxPyBeginAllowThreads();
10904 wxFileSystem::AddHandler(arg1);
10905 wxPyEndAllowThreads(__tstate);
10906 if (PyErr_Occurred()) SWIG_fail;
10907 }
10908 resultobj = SWIG_Py_Void();
10909 return resultobj;
10910 fail:
10911 return NULL;
10912 }
10913
10914
10915 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10916 PyObject *resultobj = 0;
10917 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10918 wxFileSystemHandler *result = 0 ;
10919 void *argp1 = 0 ;
10920 int res1 = 0 ;
10921 PyObject * obj0 = 0 ;
10922 char * kwnames[] = {
10923 (char *) "handler", NULL
10924 };
10925
10926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
10927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
10928 if (!SWIG_IsOK(res1)) {
10929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10930 }
10931 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10932 {
10933 PyThreadState* __tstate = wxPyBeginAllowThreads();
10934 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
10935 wxPyEndAllowThreads(__tstate);
10936 if (PyErr_Occurred()) SWIG_fail;
10937 }
10938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
10939 return resultobj;
10940 fail:
10941 return NULL;
10942 }
10943
10944
10945 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10946 PyObject *resultobj = 0;
10947
10948 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10949 {
10950 PyThreadState* __tstate = wxPyBeginAllowThreads();
10951 wxFileSystem::CleanUpHandlers();
10952 wxPyEndAllowThreads(__tstate);
10953 if (PyErr_Occurred()) SWIG_fail;
10954 }
10955 resultobj = SWIG_Py_Void();
10956 return resultobj;
10957 fail:
10958 return NULL;
10959 }
10960
10961
10962 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10963 PyObject *resultobj = 0;
10964 wxString *arg1 = 0 ;
10965 wxString result;
10966 bool temp1 = false ;
10967 PyObject * obj0 = 0 ;
10968 char * kwnames[] = {
10969 (char *) "filename", NULL
10970 };
10971
10972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10973 {
10974 arg1 = wxString_in_helper(obj0);
10975 if (arg1 == NULL) SWIG_fail;
10976 temp1 = true;
10977 }
10978 {
10979 PyThreadState* __tstate = wxPyBeginAllowThreads();
10980 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10981 wxPyEndAllowThreads(__tstate);
10982 if (PyErr_Occurred()) SWIG_fail;
10983 }
10984 {
10985 #if wxUSE_UNICODE
10986 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10987 #else
10988 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10989 #endif
10990 }
10991 {
10992 if (temp1)
10993 delete arg1;
10994 }
10995 return resultobj;
10996 fail:
10997 {
10998 if (temp1)
10999 delete arg1;
11000 }
11001 return NULL;
11002 }
11003
11004
11005 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11006 PyObject *resultobj = 0;
11007 wxString *arg1 = 0 ;
11008 wxString result;
11009 bool temp1 = false ;
11010 PyObject * obj0 = 0 ;
11011 char * kwnames[] = {
11012 (char *) "url", NULL
11013 };
11014
11015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11016 {
11017 arg1 = wxString_in_helper(obj0);
11018 if (arg1 == NULL) SWIG_fail;
11019 temp1 = true;
11020 }
11021 {
11022 PyThreadState* __tstate = wxPyBeginAllowThreads();
11023 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11024 wxPyEndAllowThreads(__tstate);
11025 if (PyErr_Occurred()) SWIG_fail;
11026 }
11027 {
11028 #if wxUSE_UNICODE
11029 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11030 #else
11031 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11032 #endif
11033 }
11034 {
11035 if (temp1)
11036 delete arg1;
11037 }
11038 return resultobj;
11039 fail:
11040 {
11041 if (temp1)
11042 delete arg1;
11043 }
11044 return NULL;
11045 }
11046
11047
11048 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11049 PyObject *obj;
11050 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11051 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11052 return SWIG_Py_Void();
11053 }
11054
11055 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11056 return SWIG_Python_InitShadowInstance(args);
11057 }
11058
11059 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11060 PyObject *resultobj = 0;
11061 wxInternetFSHandler *result = 0 ;
11062
11063 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11064 {
11065 PyThreadState* __tstate = wxPyBeginAllowThreads();
11066 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11067 wxPyEndAllowThreads(__tstate);
11068 if (PyErr_Occurred()) SWIG_fail;
11069 }
11070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11071 return resultobj;
11072 fail:
11073 return NULL;
11074 }
11075
11076
11077 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11078 PyObject *resultobj = 0;
11079 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11080 wxString *arg2 = 0 ;
11081 bool result;
11082 void *argp1 = 0 ;
11083 int res1 = 0 ;
11084 bool temp2 = false ;
11085 PyObject * obj0 = 0 ;
11086 PyObject * obj1 = 0 ;
11087 char * kwnames[] = {
11088 (char *) "self",(char *) "location", NULL
11089 };
11090
11091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11093 if (!SWIG_IsOK(res1)) {
11094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11095 }
11096 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11097 {
11098 arg2 = wxString_in_helper(obj1);
11099 if (arg2 == NULL) SWIG_fail;
11100 temp2 = true;
11101 }
11102 {
11103 PyThreadState* __tstate = wxPyBeginAllowThreads();
11104 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11105 wxPyEndAllowThreads(__tstate);
11106 if (PyErr_Occurred()) SWIG_fail;
11107 }
11108 {
11109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11110 }
11111 {
11112 if (temp2)
11113 delete arg2;
11114 }
11115 return resultobj;
11116 fail:
11117 {
11118 if (temp2)
11119 delete arg2;
11120 }
11121 return NULL;
11122 }
11123
11124
11125 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11126 PyObject *resultobj = 0;
11127 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11128 wxFileSystem *arg2 = 0 ;
11129 wxString *arg3 = 0 ;
11130 wxFSFile *result = 0 ;
11131 void *argp1 = 0 ;
11132 int res1 = 0 ;
11133 void *argp2 = 0 ;
11134 int res2 = 0 ;
11135 bool temp3 = false ;
11136 PyObject * obj0 = 0 ;
11137 PyObject * obj1 = 0 ;
11138 PyObject * obj2 = 0 ;
11139 char * kwnames[] = {
11140 (char *) "self",(char *) "fs",(char *) "location", NULL
11141 };
11142
11143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11145 if (!SWIG_IsOK(res1)) {
11146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11147 }
11148 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11149 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11150 if (!SWIG_IsOK(res2)) {
11151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11152 }
11153 if (!argp2) {
11154 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11155 }
11156 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11157 {
11158 arg3 = wxString_in_helper(obj2);
11159 if (arg3 == NULL) SWIG_fail;
11160 temp3 = true;
11161 }
11162 {
11163 PyThreadState* __tstate = wxPyBeginAllowThreads();
11164 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11165 wxPyEndAllowThreads(__tstate);
11166 if (PyErr_Occurred()) SWIG_fail;
11167 }
11168 {
11169 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11170 }
11171 {
11172 if (temp3)
11173 delete arg3;
11174 }
11175 return resultobj;
11176 fail:
11177 {
11178 if (temp3)
11179 delete arg3;
11180 }
11181 return NULL;
11182 }
11183
11184
11185 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11186 PyObject *obj;
11187 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11188 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11189 return SWIG_Py_Void();
11190 }
11191
11192 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11193 return SWIG_Python_InitShadowInstance(args);
11194 }
11195
11196 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11197 PyObject *resultobj = 0;
11198 wxZipFSHandler *result = 0 ;
11199
11200 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11201 {
11202 PyThreadState* __tstate = wxPyBeginAllowThreads();
11203 result = (wxZipFSHandler *)new wxZipFSHandler();
11204 wxPyEndAllowThreads(__tstate);
11205 if (PyErr_Occurred()) SWIG_fail;
11206 }
11207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11208 return resultobj;
11209 fail:
11210 return NULL;
11211 }
11212
11213
11214 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11215 PyObject *resultobj = 0;
11216 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11217 wxString *arg2 = 0 ;
11218 bool result;
11219 void *argp1 = 0 ;
11220 int res1 = 0 ;
11221 bool temp2 = false ;
11222 PyObject * obj0 = 0 ;
11223 PyObject * obj1 = 0 ;
11224 char * kwnames[] = {
11225 (char *) "self",(char *) "location", NULL
11226 };
11227
11228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11230 if (!SWIG_IsOK(res1)) {
11231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11232 }
11233 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11234 {
11235 arg2 = wxString_in_helper(obj1);
11236 if (arg2 == NULL) SWIG_fail;
11237 temp2 = true;
11238 }
11239 {
11240 PyThreadState* __tstate = wxPyBeginAllowThreads();
11241 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11242 wxPyEndAllowThreads(__tstate);
11243 if (PyErr_Occurred()) SWIG_fail;
11244 }
11245 {
11246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11247 }
11248 {
11249 if (temp2)
11250 delete arg2;
11251 }
11252 return resultobj;
11253 fail:
11254 {
11255 if (temp2)
11256 delete arg2;
11257 }
11258 return NULL;
11259 }
11260
11261
11262 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11263 PyObject *resultobj = 0;
11264 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11265 wxFileSystem *arg2 = 0 ;
11266 wxString *arg3 = 0 ;
11267 wxFSFile *result = 0 ;
11268 void *argp1 = 0 ;
11269 int res1 = 0 ;
11270 void *argp2 = 0 ;
11271 int res2 = 0 ;
11272 bool temp3 = false ;
11273 PyObject * obj0 = 0 ;
11274 PyObject * obj1 = 0 ;
11275 PyObject * obj2 = 0 ;
11276 char * kwnames[] = {
11277 (char *) "self",(char *) "fs",(char *) "location", NULL
11278 };
11279
11280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11282 if (!SWIG_IsOK(res1)) {
11283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11284 }
11285 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11286 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11287 if (!SWIG_IsOK(res2)) {
11288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11289 }
11290 if (!argp2) {
11291 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11292 }
11293 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11294 {
11295 arg3 = wxString_in_helper(obj2);
11296 if (arg3 == NULL) SWIG_fail;
11297 temp3 = true;
11298 }
11299 {
11300 PyThreadState* __tstate = wxPyBeginAllowThreads();
11301 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11302 wxPyEndAllowThreads(__tstate);
11303 if (PyErr_Occurred()) SWIG_fail;
11304 }
11305 {
11306 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11307 }
11308 {
11309 if (temp3)
11310 delete arg3;
11311 }
11312 return resultobj;
11313 fail:
11314 {
11315 if (temp3)
11316 delete arg3;
11317 }
11318 return NULL;
11319 }
11320
11321
11322 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11323 PyObject *resultobj = 0;
11324 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11325 wxString *arg2 = 0 ;
11326 int arg3 = (int) 0 ;
11327 wxString result;
11328 void *argp1 = 0 ;
11329 int res1 = 0 ;
11330 bool temp2 = false ;
11331 int val3 ;
11332 int ecode3 = 0 ;
11333 PyObject * obj0 = 0 ;
11334 PyObject * obj1 = 0 ;
11335 PyObject * obj2 = 0 ;
11336 char * kwnames[] = {
11337 (char *) "self",(char *) "spec",(char *) "flags", NULL
11338 };
11339
11340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11342 if (!SWIG_IsOK(res1)) {
11343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11344 }
11345 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11346 {
11347 arg2 = wxString_in_helper(obj1);
11348 if (arg2 == NULL) SWIG_fail;
11349 temp2 = true;
11350 }
11351 if (obj2) {
11352 ecode3 = SWIG_AsVal_int(obj2, &val3);
11353 if (!SWIG_IsOK(ecode3)) {
11354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11355 }
11356 arg3 = static_cast< int >(val3);
11357 }
11358 {
11359 PyThreadState* __tstate = wxPyBeginAllowThreads();
11360 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11361 wxPyEndAllowThreads(__tstate);
11362 if (PyErr_Occurred()) SWIG_fail;
11363 }
11364 {
11365 #if wxUSE_UNICODE
11366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11367 #else
11368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11369 #endif
11370 }
11371 {
11372 if (temp2)
11373 delete arg2;
11374 }
11375 return resultobj;
11376 fail:
11377 {
11378 if (temp2)
11379 delete arg2;
11380 }
11381 return NULL;
11382 }
11383
11384
11385 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11386 PyObject *resultobj = 0;
11387 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11388 wxString result;
11389 void *argp1 = 0 ;
11390 int res1 = 0 ;
11391 PyObject *swig_obj[1] ;
11392
11393 if (!args) SWIG_fail;
11394 swig_obj[0] = args;
11395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11396 if (!SWIG_IsOK(res1)) {
11397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11398 }
11399 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11400 {
11401 PyThreadState* __tstate = wxPyBeginAllowThreads();
11402 result = (arg1)->FindNext();
11403 wxPyEndAllowThreads(__tstate);
11404 if (PyErr_Occurred()) SWIG_fail;
11405 }
11406 {
11407 #if wxUSE_UNICODE
11408 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11409 #else
11410 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11411 #endif
11412 }
11413 return resultobj;
11414 fail:
11415 return NULL;
11416 }
11417
11418
11419 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11420 PyObject *obj;
11421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11422 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11423 return SWIG_Py_Void();
11424 }
11425
11426 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11427 return SWIG_Python_InitShadowInstance(args);
11428 }
11429
11430 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11431 PyObject *resultobj = 0;
11432 wxString *arg1 = 0 ;
11433 wxImage *arg2 = 0 ;
11434 long arg3 ;
11435 bool temp1 = false ;
11436 void *argp2 = 0 ;
11437 int res2 = 0 ;
11438 long val3 ;
11439 int ecode3 = 0 ;
11440 PyObject * obj0 = 0 ;
11441 PyObject * obj1 = 0 ;
11442 PyObject * obj2 = 0 ;
11443 char * kwnames[] = {
11444 (char *) "filename",(char *) "image",(char *) "type", NULL
11445 };
11446
11447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11448 {
11449 arg1 = wxString_in_helper(obj0);
11450 if (arg1 == NULL) SWIG_fail;
11451 temp1 = true;
11452 }
11453 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11454 if (!SWIG_IsOK(res2)) {
11455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11456 }
11457 if (!argp2) {
11458 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11459 }
11460 arg2 = reinterpret_cast< wxImage * >(argp2);
11461 ecode3 = SWIG_AsVal_long(obj2, &val3);
11462 if (!SWIG_IsOK(ecode3)) {
11463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11464 }
11465 arg3 = static_cast< long >(val3);
11466 {
11467 PyThreadState* __tstate = wxPyBeginAllowThreads();
11468 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11469 wxPyEndAllowThreads(__tstate);
11470 if (PyErr_Occurred()) SWIG_fail;
11471 }
11472 resultobj = SWIG_Py_Void();
11473 {
11474 if (temp1)
11475 delete arg1;
11476 }
11477 return resultobj;
11478 fail:
11479 {
11480 if (temp1)
11481 delete arg1;
11482 }
11483 return NULL;
11484 }
11485
11486
11487 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11488 PyObject *resultobj = 0;
11489 wxString *arg1 = 0 ;
11490 wxBitmap *arg2 = 0 ;
11491 long arg3 ;
11492 bool temp1 = false ;
11493 void *argp2 = 0 ;
11494 int res2 = 0 ;
11495 long val3 ;
11496 int ecode3 = 0 ;
11497 PyObject * obj0 = 0 ;
11498 PyObject * obj1 = 0 ;
11499 PyObject * obj2 = 0 ;
11500 char * kwnames[] = {
11501 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11502 };
11503
11504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11505 {
11506 arg1 = wxString_in_helper(obj0);
11507 if (arg1 == NULL) SWIG_fail;
11508 temp1 = true;
11509 }
11510 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11511 if (!SWIG_IsOK(res2)) {
11512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11513 }
11514 if (!argp2) {
11515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11516 }
11517 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11518 ecode3 = SWIG_AsVal_long(obj2, &val3);
11519 if (!SWIG_IsOK(ecode3)) {
11520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11521 }
11522 arg3 = static_cast< long >(val3);
11523 {
11524 PyThreadState* __tstate = wxPyBeginAllowThreads();
11525 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11526 wxPyEndAllowThreads(__tstate);
11527 if (PyErr_Occurred()) SWIG_fail;
11528 }
11529 resultobj = SWIG_Py_Void();
11530 {
11531 if (temp1)
11532 delete arg1;
11533 }
11534 return resultobj;
11535 fail:
11536 {
11537 if (temp1)
11538 delete arg1;
11539 }
11540 return NULL;
11541 }
11542
11543
11544 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11545 PyObject *resultobj = 0;
11546 wxString *arg1 = 0 ;
11547 PyObject *arg2 = (PyObject *) 0 ;
11548 bool temp1 = false ;
11549 PyObject * obj0 = 0 ;
11550 PyObject * obj1 = 0 ;
11551 char * kwnames[] = {
11552 (char *) "filename",(char *) "data", NULL
11553 };
11554
11555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11556 {
11557 arg1 = wxString_in_helper(obj0);
11558 if (arg1 == NULL) SWIG_fail;
11559 temp1 = true;
11560 }
11561 arg2 = obj1;
11562 {
11563 PyThreadState* __tstate = wxPyBeginAllowThreads();
11564 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11565 wxPyEndAllowThreads(__tstate);
11566 if (PyErr_Occurred()) SWIG_fail;
11567 }
11568 resultobj = SWIG_Py_Void();
11569 {
11570 if (temp1)
11571 delete arg1;
11572 }
11573 return resultobj;
11574 fail:
11575 {
11576 if (temp1)
11577 delete arg1;
11578 }
11579 return NULL;
11580 }
11581
11582
11583 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11584 PyObject *resultobj = 0;
11585 wxMemoryFSHandler *result = 0 ;
11586
11587 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11588 {
11589 PyThreadState* __tstate = wxPyBeginAllowThreads();
11590 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11591 wxPyEndAllowThreads(__tstate);
11592 if (PyErr_Occurred()) SWIG_fail;
11593 }
11594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11595 return resultobj;
11596 fail:
11597 return NULL;
11598 }
11599
11600
11601 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11602 PyObject *resultobj = 0;
11603 wxString *arg1 = 0 ;
11604 bool temp1 = false ;
11605 PyObject * obj0 = 0 ;
11606 char * kwnames[] = {
11607 (char *) "filename", NULL
11608 };
11609
11610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11611 {
11612 arg1 = wxString_in_helper(obj0);
11613 if (arg1 == NULL) SWIG_fail;
11614 temp1 = true;
11615 }
11616 {
11617 PyThreadState* __tstate = wxPyBeginAllowThreads();
11618 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11619 wxPyEndAllowThreads(__tstate);
11620 if (PyErr_Occurred()) SWIG_fail;
11621 }
11622 resultobj = SWIG_Py_Void();
11623 {
11624 if (temp1)
11625 delete arg1;
11626 }
11627 return resultobj;
11628 fail:
11629 {
11630 if (temp1)
11631 delete arg1;
11632 }
11633 return NULL;
11634 }
11635
11636
11637 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11638 PyObject *resultobj = 0;
11639 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11640 wxString *arg2 = 0 ;
11641 bool result;
11642 void *argp1 = 0 ;
11643 int res1 = 0 ;
11644 bool temp2 = false ;
11645 PyObject * obj0 = 0 ;
11646 PyObject * obj1 = 0 ;
11647 char * kwnames[] = {
11648 (char *) "self",(char *) "location", NULL
11649 };
11650
11651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11653 if (!SWIG_IsOK(res1)) {
11654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11655 }
11656 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11657 {
11658 arg2 = wxString_in_helper(obj1);
11659 if (arg2 == NULL) SWIG_fail;
11660 temp2 = true;
11661 }
11662 {
11663 PyThreadState* __tstate = wxPyBeginAllowThreads();
11664 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11665 wxPyEndAllowThreads(__tstate);
11666 if (PyErr_Occurred()) SWIG_fail;
11667 }
11668 {
11669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11670 }
11671 {
11672 if (temp2)
11673 delete arg2;
11674 }
11675 return resultobj;
11676 fail:
11677 {
11678 if (temp2)
11679 delete arg2;
11680 }
11681 return NULL;
11682 }
11683
11684
11685 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11686 PyObject *resultobj = 0;
11687 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11688 wxFileSystem *arg2 = 0 ;
11689 wxString *arg3 = 0 ;
11690 wxFSFile *result = 0 ;
11691 void *argp1 = 0 ;
11692 int res1 = 0 ;
11693 void *argp2 = 0 ;
11694 int res2 = 0 ;
11695 bool temp3 = false ;
11696 PyObject * obj0 = 0 ;
11697 PyObject * obj1 = 0 ;
11698 PyObject * obj2 = 0 ;
11699 char * kwnames[] = {
11700 (char *) "self",(char *) "fs",(char *) "location", NULL
11701 };
11702
11703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11705 if (!SWIG_IsOK(res1)) {
11706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11707 }
11708 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11709 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11710 if (!SWIG_IsOK(res2)) {
11711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11712 }
11713 if (!argp2) {
11714 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11715 }
11716 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11717 {
11718 arg3 = wxString_in_helper(obj2);
11719 if (arg3 == NULL) SWIG_fail;
11720 temp3 = true;
11721 }
11722 {
11723 PyThreadState* __tstate = wxPyBeginAllowThreads();
11724 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11725 wxPyEndAllowThreads(__tstate);
11726 if (PyErr_Occurred()) SWIG_fail;
11727 }
11728 {
11729 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11730 }
11731 {
11732 if (temp3)
11733 delete arg3;
11734 }
11735 return resultobj;
11736 fail:
11737 {
11738 if (temp3)
11739 delete arg3;
11740 }
11741 return NULL;
11742 }
11743
11744
11745 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11746 PyObject *resultobj = 0;
11747 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11748 wxString *arg2 = 0 ;
11749 int arg3 = (int) 0 ;
11750 wxString result;
11751 void *argp1 = 0 ;
11752 int res1 = 0 ;
11753 bool temp2 = false ;
11754 int val3 ;
11755 int ecode3 = 0 ;
11756 PyObject * obj0 = 0 ;
11757 PyObject * obj1 = 0 ;
11758 PyObject * obj2 = 0 ;
11759 char * kwnames[] = {
11760 (char *) "self",(char *) "spec",(char *) "flags", NULL
11761 };
11762
11763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11765 if (!SWIG_IsOK(res1)) {
11766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11767 }
11768 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11769 {
11770 arg2 = wxString_in_helper(obj1);
11771 if (arg2 == NULL) SWIG_fail;
11772 temp2 = true;
11773 }
11774 if (obj2) {
11775 ecode3 = SWIG_AsVal_int(obj2, &val3);
11776 if (!SWIG_IsOK(ecode3)) {
11777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11778 }
11779 arg3 = static_cast< int >(val3);
11780 }
11781 {
11782 PyThreadState* __tstate = wxPyBeginAllowThreads();
11783 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11784 wxPyEndAllowThreads(__tstate);
11785 if (PyErr_Occurred()) SWIG_fail;
11786 }
11787 {
11788 #if wxUSE_UNICODE
11789 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11790 #else
11791 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11792 #endif
11793 }
11794 {
11795 if (temp2)
11796 delete arg2;
11797 }
11798 return resultobj;
11799 fail:
11800 {
11801 if (temp2)
11802 delete arg2;
11803 }
11804 return NULL;
11805 }
11806
11807
11808 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11809 PyObject *resultobj = 0;
11810 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11811 wxString result;
11812 void *argp1 = 0 ;
11813 int res1 = 0 ;
11814 PyObject *swig_obj[1] ;
11815
11816 if (!args) SWIG_fail;
11817 swig_obj[0] = args;
11818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11819 if (!SWIG_IsOK(res1)) {
11820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11821 }
11822 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11823 {
11824 PyThreadState* __tstate = wxPyBeginAllowThreads();
11825 result = (arg1)->FindNext();
11826 wxPyEndAllowThreads(__tstate);
11827 if (PyErr_Occurred()) SWIG_fail;
11828 }
11829 {
11830 #if wxUSE_UNICODE
11831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11832 #else
11833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11834 #endif
11835 }
11836 return resultobj;
11837 fail:
11838 return NULL;
11839 }
11840
11841
11842 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11843 PyObject *obj;
11844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11845 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11846 return SWIG_Py_Void();
11847 }
11848
11849 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11850 return SWIG_Python_InitShadowInstance(args);
11851 }
11852
11853 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11854 PyObject *resultobj = 0;
11855 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11856 wxString result;
11857 void *argp1 = 0 ;
11858 int res1 = 0 ;
11859 PyObject *swig_obj[1] ;
11860
11861 if (!args) SWIG_fail;
11862 swig_obj[0] = args;
11863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11864 if (!SWIG_IsOK(res1)) {
11865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11866 }
11867 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11868 {
11869 PyThreadState* __tstate = wxPyBeginAllowThreads();
11870 result = (arg1)->GetName();
11871 wxPyEndAllowThreads(__tstate);
11872 if (PyErr_Occurred()) SWIG_fail;
11873 }
11874 {
11875 #if wxUSE_UNICODE
11876 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11877 #else
11878 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11879 #endif
11880 }
11881 return resultobj;
11882 fail:
11883 return NULL;
11884 }
11885
11886
11887 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11888 PyObject *resultobj = 0;
11889 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11890 wxString result;
11891 void *argp1 = 0 ;
11892 int res1 = 0 ;
11893 PyObject *swig_obj[1] ;
11894
11895 if (!args) SWIG_fail;
11896 swig_obj[0] = args;
11897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11898 if (!SWIG_IsOK(res1)) {
11899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11900 }
11901 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11902 {
11903 PyThreadState* __tstate = wxPyBeginAllowThreads();
11904 result = (arg1)->GetExtension();
11905 wxPyEndAllowThreads(__tstate);
11906 if (PyErr_Occurred()) SWIG_fail;
11907 }
11908 {
11909 #if wxUSE_UNICODE
11910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11911 #else
11912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11913 #endif
11914 }
11915 return resultobj;
11916 fail:
11917 return NULL;
11918 }
11919
11920
11921 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11922 PyObject *resultobj = 0;
11923 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11924 long result;
11925 void *argp1 = 0 ;
11926 int res1 = 0 ;
11927 PyObject *swig_obj[1] ;
11928
11929 if (!args) SWIG_fail;
11930 swig_obj[0] = args;
11931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11932 if (!SWIG_IsOK(res1)) {
11933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11934 }
11935 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11936 {
11937 PyThreadState* __tstate = wxPyBeginAllowThreads();
11938 result = (long)(arg1)->GetType();
11939 wxPyEndAllowThreads(__tstate);
11940 if (PyErr_Occurred()) SWIG_fail;
11941 }
11942 resultobj = SWIG_From_long(static_cast< long >(result));
11943 return resultobj;
11944 fail:
11945 return NULL;
11946 }
11947
11948
11949 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11950 PyObject *resultobj = 0;
11951 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11952 wxString result;
11953 void *argp1 = 0 ;
11954 int res1 = 0 ;
11955 PyObject *swig_obj[1] ;
11956
11957 if (!args) SWIG_fail;
11958 swig_obj[0] = args;
11959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11960 if (!SWIG_IsOK(res1)) {
11961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11962 }
11963 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11964 {
11965 PyThreadState* __tstate = wxPyBeginAllowThreads();
11966 result = (arg1)->GetMimeType();
11967 wxPyEndAllowThreads(__tstate);
11968 if (PyErr_Occurred()) SWIG_fail;
11969 }
11970 {
11971 #if wxUSE_UNICODE
11972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11973 #else
11974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11975 #endif
11976 }
11977 return resultobj;
11978 fail:
11979 return NULL;
11980 }
11981
11982
11983 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11984 PyObject *resultobj = 0;
11985 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11986 wxString *arg2 = 0 ;
11987 bool result;
11988 void *argp1 = 0 ;
11989 int res1 = 0 ;
11990 bool temp2 = false ;
11991 PyObject * obj0 = 0 ;
11992 PyObject * obj1 = 0 ;
11993 char * kwnames[] = {
11994 (char *) "self",(char *) "name", NULL
11995 };
11996
11997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11999 if (!SWIG_IsOK(res1)) {
12000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12001 }
12002 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12003 {
12004 arg2 = wxString_in_helper(obj1);
12005 if (arg2 == NULL) SWIG_fail;
12006 temp2 = true;
12007 }
12008 {
12009 PyThreadState* __tstate = wxPyBeginAllowThreads();
12010 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12011 wxPyEndAllowThreads(__tstate);
12012 if (PyErr_Occurred()) SWIG_fail;
12013 }
12014 {
12015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12016 }
12017 {
12018 if (temp2)
12019 delete arg2;
12020 }
12021 return resultobj;
12022 fail:
12023 {
12024 if (temp2)
12025 delete arg2;
12026 }
12027 return NULL;
12028 }
12029
12030
12031 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12032 PyObject *resultobj = 0;
12033 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12034 wxInputStream *arg2 = 0 ;
12035 bool result;
12036 void *argp1 = 0 ;
12037 int res1 = 0 ;
12038 wxPyInputStream *temp2 ;
12039 bool created2 ;
12040 PyObject * obj0 = 0 ;
12041 PyObject * obj1 = 0 ;
12042 char * kwnames[] = {
12043 (char *) "self",(char *) "stream", NULL
12044 };
12045
12046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12048 if (!SWIG_IsOK(res1)) {
12049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12050 }
12051 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12052 {
12053 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12054 arg2 = temp2->m_wxis;
12055 created2 = false;
12056 } else {
12057 PyErr_Clear(); // clear the failure of the wxPyConvert above
12058 arg2 = wxPyCBInputStream_create(obj1, false);
12059 if (arg2 == NULL) {
12060 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12061 SWIG_fail;
12062 }
12063 created2 = true;
12064 }
12065 }
12066 {
12067 PyThreadState* __tstate = wxPyBeginAllowThreads();
12068 result = (bool)(arg1)->CanRead(*arg2);
12069 wxPyEndAllowThreads(__tstate);
12070 if (PyErr_Occurred()) SWIG_fail;
12071 }
12072 {
12073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12074 }
12075 {
12076 if (created2) delete arg2;
12077 }
12078 return resultobj;
12079 fail:
12080 {
12081 if (created2) delete arg2;
12082 }
12083 return NULL;
12084 }
12085
12086
12087 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12088 PyObject *resultobj = 0;
12089 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12090 wxString *arg2 = 0 ;
12091 void *argp1 = 0 ;
12092 int res1 = 0 ;
12093 bool temp2 = false ;
12094 PyObject * obj0 = 0 ;
12095 PyObject * obj1 = 0 ;
12096 char * kwnames[] = {
12097 (char *) "self",(char *) "name", NULL
12098 };
12099
12100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12102 if (!SWIG_IsOK(res1)) {
12103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12104 }
12105 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12106 {
12107 arg2 = wxString_in_helper(obj1);
12108 if (arg2 == NULL) SWIG_fail;
12109 temp2 = true;
12110 }
12111 {
12112 PyThreadState* __tstate = wxPyBeginAllowThreads();
12113 (arg1)->SetName((wxString const &)*arg2);
12114 wxPyEndAllowThreads(__tstate);
12115 if (PyErr_Occurred()) SWIG_fail;
12116 }
12117 resultobj = SWIG_Py_Void();
12118 {
12119 if (temp2)
12120 delete arg2;
12121 }
12122 return resultobj;
12123 fail:
12124 {
12125 if (temp2)
12126 delete arg2;
12127 }
12128 return NULL;
12129 }
12130
12131
12132 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12133 PyObject *resultobj = 0;
12134 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12135 wxString *arg2 = 0 ;
12136 void *argp1 = 0 ;
12137 int res1 = 0 ;
12138 bool temp2 = false ;
12139 PyObject * obj0 = 0 ;
12140 PyObject * obj1 = 0 ;
12141 char * kwnames[] = {
12142 (char *) "self",(char *) "extension", NULL
12143 };
12144
12145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12147 if (!SWIG_IsOK(res1)) {
12148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12149 }
12150 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12151 {
12152 arg2 = wxString_in_helper(obj1);
12153 if (arg2 == NULL) SWIG_fail;
12154 temp2 = true;
12155 }
12156 {
12157 PyThreadState* __tstate = wxPyBeginAllowThreads();
12158 (arg1)->SetExtension((wxString const &)*arg2);
12159 wxPyEndAllowThreads(__tstate);
12160 if (PyErr_Occurred()) SWIG_fail;
12161 }
12162 resultobj = SWIG_Py_Void();
12163 {
12164 if (temp2)
12165 delete arg2;
12166 }
12167 return resultobj;
12168 fail:
12169 {
12170 if (temp2)
12171 delete arg2;
12172 }
12173 return NULL;
12174 }
12175
12176
12177 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12178 PyObject *resultobj = 0;
12179 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12180 long arg2 ;
12181 void *argp1 = 0 ;
12182 int res1 = 0 ;
12183 long val2 ;
12184 int ecode2 = 0 ;
12185 PyObject * obj0 = 0 ;
12186 PyObject * obj1 = 0 ;
12187 char * kwnames[] = {
12188 (char *) "self",(char *) "type", NULL
12189 };
12190
12191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12193 if (!SWIG_IsOK(res1)) {
12194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12195 }
12196 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12197 ecode2 = SWIG_AsVal_long(obj1, &val2);
12198 if (!SWIG_IsOK(ecode2)) {
12199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12200 }
12201 arg2 = static_cast< long >(val2);
12202 {
12203 PyThreadState* __tstate = wxPyBeginAllowThreads();
12204 (arg1)->SetType(arg2);
12205 wxPyEndAllowThreads(__tstate);
12206 if (PyErr_Occurred()) SWIG_fail;
12207 }
12208 resultobj = SWIG_Py_Void();
12209 return resultobj;
12210 fail:
12211 return NULL;
12212 }
12213
12214
12215 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12216 PyObject *resultobj = 0;
12217 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12218 wxString *arg2 = 0 ;
12219 void *argp1 = 0 ;
12220 int res1 = 0 ;
12221 bool temp2 = false ;
12222 PyObject * obj0 = 0 ;
12223 PyObject * obj1 = 0 ;
12224 char * kwnames[] = {
12225 (char *) "self",(char *) "mimetype", NULL
12226 };
12227
12228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12230 if (!SWIG_IsOK(res1)) {
12231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12232 }
12233 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12234 {
12235 arg2 = wxString_in_helper(obj1);
12236 if (arg2 == NULL) SWIG_fail;
12237 temp2 = true;
12238 }
12239 {
12240 PyThreadState* __tstate = wxPyBeginAllowThreads();
12241 (arg1)->SetMimeType((wxString const &)*arg2);
12242 wxPyEndAllowThreads(__tstate);
12243 if (PyErr_Occurred()) SWIG_fail;
12244 }
12245 resultobj = SWIG_Py_Void();
12246 {
12247 if (temp2)
12248 delete arg2;
12249 }
12250 return resultobj;
12251 fail:
12252 {
12253 if (temp2)
12254 delete arg2;
12255 }
12256 return NULL;
12257 }
12258
12259
12260 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12261 PyObject *obj;
12262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12263 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12264 return SWIG_Py_Void();
12265 }
12266
12267 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12268 PyObject *resultobj = 0;
12269 wxPyImageHandler *result = 0 ;
12270
12271 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12272 {
12273 PyThreadState* __tstate = wxPyBeginAllowThreads();
12274 result = (wxPyImageHandler *)new wxPyImageHandler();
12275 wxPyEndAllowThreads(__tstate);
12276 if (PyErr_Occurred()) SWIG_fail;
12277 }
12278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12279 return resultobj;
12280 fail:
12281 return NULL;
12282 }
12283
12284
12285 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12286 PyObject *resultobj = 0;
12287 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12288 PyObject *arg2 = (PyObject *) 0 ;
12289 void *argp1 = 0 ;
12290 int res1 = 0 ;
12291 PyObject * obj0 = 0 ;
12292 PyObject * obj1 = 0 ;
12293 char * kwnames[] = {
12294 (char *) "self",(char *) "self", NULL
12295 };
12296
12297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12299 if (!SWIG_IsOK(res1)) {
12300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12301 }
12302 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12303 arg2 = obj1;
12304 {
12305 PyThreadState* __tstate = wxPyBeginAllowThreads();
12306 (arg1)->_SetSelf(arg2);
12307 wxPyEndAllowThreads(__tstate);
12308 if (PyErr_Occurred()) SWIG_fail;
12309 }
12310 resultobj = SWIG_Py_Void();
12311 return resultobj;
12312 fail:
12313 return NULL;
12314 }
12315
12316
12317 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12318 PyObject *obj;
12319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12320 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12321 return SWIG_Py_Void();
12322 }
12323
12324 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12325 return SWIG_Python_InitShadowInstance(args);
12326 }
12327
12328 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12329 PyObject *resultobj = 0;
12330 wxImageHistogram *result = 0 ;
12331
12332 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12333 {
12334 PyThreadState* __tstate = wxPyBeginAllowThreads();
12335 result = (wxImageHistogram *)new wxImageHistogram();
12336 wxPyEndAllowThreads(__tstate);
12337 if (PyErr_Occurred()) SWIG_fail;
12338 }
12339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12340 return resultobj;
12341 fail:
12342 return NULL;
12343 }
12344
12345
12346 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12347 PyObject *resultobj = 0;
12348 byte arg1 ;
12349 byte arg2 ;
12350 byte arg3 ;
12351 unsigned long result;
12352 unsigned char val1 ;
12353 int ecode1 = 0 ;
12354 unsigned char val2 ;
12355 int ecode2 = 0 ;
12356 unsigned char val3 ;
12357 int ecode3 = 0 ;
12358 PyObject * obj0 = 0 ;
12359 PyObject * obj1 = 0 ;
12360 PyObject * obj2 = 0 ;
12361 char * kwnames[] = {
12362 (char *) "r",(char *) "g",(char *) "b", NULL
12363 };
12364
12365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12366 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12367 if (!SWIG_IsOK(ecode1)) {
12368 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12369 }
12370 arg1 = static_cast< byte >(val1);
12371 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12372 if (!SWIG_IsOK(ecode2)) {
12373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12374 }
12375 arg2 = static_cast< byte >(val2);
12376 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12377 if (!SWIG_IsOK(ecode3)) {
12378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12379 }
12380 arg3 = static_cast< byte >(val3);
12381 {
12382 PyThreadState* __tstate = wxPyBeginAllowThreads();
12383 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12384 wxPyEndAllowThreads(__tstate);
12385 if (PyErr_Occurred()) SWIG_fail;
12386 }
12387 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12388 return resultobj;
12389 fail:
12390 return NULL;
12391 }
12392
12393
12394 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12395 PyObject *resultobj = 0;
12396 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12397 byte *arg2 = (byte *) 0 ;
12398 byte *arg3 = (byte *) 0 ;
12399 byte *arg4 = (byte *) 0 ;
12400 byte arg5 = (byte) 1 ;
12401 byte arg6 = (byte) 0 ;
12402 byte arg7 = (byte) 0 ;
12403 bool result;
12404 void *argp1 = 0 ;
12405 int res1 = 0 ;
12406 byte temp2 ;
12407 int res2 = SWIG_TMPOBJ ;
12408 byte temp3 ;
12409 int res3 = SWIG_TMPOBJ ;
12410 byte temp4 ;
12411 int res4 = SWIG_TMPOBJ ;
12412 unsigned char val5 ;
12413 int ecode5 = 0 ;
12414 unsigned char val6 ;
12415 int ecode6 = 0 ;
12416 unsigned char val7 ;
12417 int ecode7 = 0 ;
12418 PyObject * obj0 = 0 ;
12419 PyObject * obj1 = 0 ;
12420 PyObject * obj2 = 0 ;
12421 PyObject * obj3 = 0 ;
12422 char * kwnames[] = {
12423 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12424 };
12425
12426 arg2 = &temp2;
12427 arg3 = &temp3;
12428 arg4 = &temp4;
12429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12431 if (!SWIG_IsOK(res1)) {
12432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12433 }
12434 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12435 if (obj1) {
12436 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12437 if (!SWIG_IsOK(ecode5)) {
12438 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12439 }
12440 arg5 = static_cast< byte >(val5);
12441 }
12442 if (obj2) {
12443 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12444 if (!SWIG_IsOK(ecode6)) {
12445 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12446 }
12447 arg6 = static_cast< byte >(val6);
12448 }
12449 if (obj3) {
12450 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12451 if (!SWIG_IsOK(ecode7)) {
12452 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12453 }
12454 arg7 = static_cast< byte >(val7);
12455 }
12456 {
12457 PyThreadState* __tstate = wxPyBeginAllowThreads();
12458 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12459 wxPyEndAllowThreads(__tstate);
12460 if (PyErr_Occurred()) SWIG_fail;
12461 }
12462 {
12463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12464 }
12465 if (SWIG_IsTmpObj(res2)) {
12466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12467 } else {
12468 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12469 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12470 }
12471 if (SWIG_IsTmpObj(res3)) {
12472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12473 } else {
12474 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12475 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12476 }
12477 if (SWIG_IsTmpObj(res4)) {
12478 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12479 } else {
12480 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12481 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12482 }
12483 return resultobj;
12484 fail:
12485 return NULL;
12486 }
12487
12488
12489 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12490 PyObject *resultobj = 0;
12491 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12492 unsigned long arg2 ;
12493 unsigned long result;
12494 void *argp1 = 0 ;
12495 int res1 = 0 ;
12496 unsigned long val2 ;
12497 int ecode2 = 0 ;
12498 PyObject * obj0 = 0 ;
12499 PyObject * obj1 = 0 ;
12500 char * kwnames[] = {
12501 (char *) "self",(char *) "key", NULL
12502 };
12503
12504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12506 if (!SWIG_IsOK(res1)) {
12507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12508 }
12509 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12510 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12511 if (!SWIG_IsOK(ecode2)) {
12512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12513 }
12514 arg2 = static_cast< unsigned long >(val2);
12515 {
12516 PyThreadState* __tstate = wxPyBeginAllowThreads();
12517 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12518 wxPyEndAllowThreads(__tstate);
12519 if (PyErr_Occurred()) SWIG_fail;
12520 }
12521 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12522 return resultobj;
12523 fail:
12524 return NULL;
12525 }
12526
12527
12528 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12529 PyObject *resultobj = 0;
12530 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12531 byte arg2 ;
12532 byte arg3 ;
12533 byte arg4 ;
12534 unsigned long result;
12535 void *argp1 = 0 ;
12536 int res1 = 0 ;
12537 unsigned char val2 ;
12538 int ecode2 = 0 ;
12539 unsigned char val3 ;
12540 int ecode3 = 0 ;
12541 unsigned char val4 ;
12542 int ecode4 = 0 ;
12543 PyObject * obj0 = 0 ;
12544 PyObject * obj1 = 0 ;
12545 PyObject * obj2 = 0 ;
12546 PyObject * obj3 = 0 ;
12547 char * kwnames[] = {
12548 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12549 };
12550
12551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12553 if (!SWIG_IsOK(res1)) {
12554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12555 }
12556 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12557 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12558 if (!SWIG_IsOK(ecode2)) {
12559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12560 }
12561 arg2 = static_cast< byte >(val2);
12562 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12563 if (!SWIG_IsOK(ecode3)) {
12564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12565 }
12566 arg3 = static_cast< byte >(val3);
12567 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12568 if (!SWIG_IsOK(ecode4)) {
12569 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12570 }
12571 arg4 = static_cast< byte >(val4);
12572 {
12573 PyThreadState* __tstate = wxPyBeginAllowThreads();
12574 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12575 wxPyEndAllowThreads(__tstate);
12576 if (PyErr_Occurred()) SWIG_fail;
12577 }
12578 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12579 return resultobj;
12580 fail:
12581 return NULL;
12582 }
12583
12584
12585 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12586 PyObject *resultobj = 0;
12587 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12588 wxColour *arg2 = 0 ;
12589 unsigned long result;
12590 void *argp1 = 0 ;
12591 int res1 = 0 ;
12592 wxColour temp2 ;
12593 PyObject * obj0 = 0 ;
12594 PyObject * obj1 = 0 ;
12595 char * kwnames[] = {
12596 (char *) "self",(char *) "colour", NULL
12597 };
12598
12599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12601 if (!SWIG_IsOK(res1)) {
12602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12603 }
12604 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12605 {
12606 arg2 = &temp2;
12607 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12608 }
12609 {
12610 PyThreadState* __tstate = wxPyBeginAllowThreads();
12611 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12612 wxPyEndAllowThreads(__tstate);
12613 if (PyErr_Occurred()) SWIG_fail;
12614 }
12615 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12616 return resultobj;
12617 fail:
12618 return NULL;
12619 }
12620
12621
12622 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12623 PyObject *obj;
12624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12625 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12626 return SWIG_Py_Void();
12627 }
12628
12629 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12630 return SWIG_Python_InitShadowInstance(args);
12631 }
12632
12633 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12634 PyObject *resultobj = 0;
12635 byte arg1 = (byte) 0 ;
12636 byte arg2 = (byte) 0 ;
12637 byte arg3 = (byte) 0 ;
12638 wxImage_RGBValue *result = 0 ;
12639 unsigned char val1 ;
12640 int ecode1 = 0 ;
12641 unsigned char val2 ;
12642 int ecode2 = 0 ;
12643 unsigned char val3 ;
12644 int ecode3 = 0 ;
12645 PyObject * obj0 = 0 ;
12646 PyObject * obj1 = 0 ;
12647 PyObject * obj2 = 0 ;
12648 char * kwnames[] = {
12649 (char *) "r",(char *) "g",(char *) "b", NULL
12650 };
12651
12652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12653 if (obj0) {
12654 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12655 if (!SWIG_IsOK(ecode1)) {
12656 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12657 }
12658 arg1 = static_cast< byte >(val1);
12659 }
12660 if (obj1) {
12661 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12662 if (!SWIG_IsOK(ecode2)) {
12663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12664 }
12665 arg2 = static_cast< byte >(val2);
12666 }
12667 if (obj2) {
12668 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12669 if (!SWIG_IsOK(ecode3)) {
12670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12671 }
12672 arg3 = static_cast< byte >(val3);
12673 }
12674 {
12675 PyThreadState* __tstate = wxPyBeginAllowThreads();
12676 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12677 wxPyEndAllowThreads(__tstate);
12678 if (PyErr_Occurred()) SWIG_fail;
12679 }
12680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12681 return resultobj;
12682 fail:
12683 return NULL;
12684 }
12685
12686
12687 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12688 PyObject *resultobj = 0;
12689 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12690 byte arg2 ;
12691 void *argp1 = 0 ;
12692 int res1 = 0 ;
12693 unsigned char val2 ;
12694 int ecode2 = 0 ;
12695 PyObject *swig_obj[2] ;
12696
12697 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12699 if (!SWIG_IsOK(res1)) {
12700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12701 }
12702 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12703 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12704 if (!SWIG_IsOK(ecode2)) {
12705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12706 }
12707 arg2 = static_cast< byte >(val2);
12708 if (arg1) (arg1)->red = arg2;
12709
12710 resultobj = SWIG_Py_Void();
12711 return resultobj;
12712 fail:
12713 return NULL;
12714 }
12715
12716
12717 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12718 PyObject *resultobj = 0;
12719 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12720 byte result;
12721 void *argp1 = 0 ;
12722 int res1 = 0 ;
12723 PyObject *swig_obj[1] ;
12724
12725 if (!args) SWIG_fail;
12726 swig_obj[0] = args;
12727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12728 if (!SWIG_IsOK(res1)) {
12729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12730 }
12731 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12732 result = (byte) ((arg1)->red);
12733 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12734 return resultobj;
12735 fail:
12736 return NULL;
12737 }
12738
12739
12740 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12741 PyObject *resultobj = 0;
12742 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12743 byte arg2 ;
12744 void *argp1 = 0 ;
12745 int res1 = 0 ;
12746 unsigned char val2 ;
12747 int ecode2 = 0 ;
12748 PyObject *swig_obj[2] ;
12749
12750 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12752 if (!SWIG_IsOK(res1)) {
12753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12754 }
12755 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12756 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12757 if (!SWIG_IsOK(ecode2)) {
12758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12759 }
12760 arg2 = static_cast< byte >(val2);
12761 if (arg1) (arg1)->green = arg2;
12762
12763 resultobj = SWIG_Py_Void();
12764 return resultobj;
12765 fail:
12766 return NULL;
12767 }
12768
12769
12770 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12771 PyObject *resultobj = 0;
12772 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12773 byte result;
12774 void *argp1 = 0 ;
12775 int res1 = 0 ;
12776 PyObject *swig_obj[1] ;
12777
12778 if (!args) SWIG_fail;
12779 swig_obj[0] = args;
12780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12781 if (!SWIG_IsOK(res1)) {
12782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12783 }
12784 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12785 result = (byte) ((arg1)->green);
12786 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12787 return resultobj;
12788 fail:
12789 return NULL;
12790 }
12791
12792
12793 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12794 PyObject *resultobj = 0;
12795 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12796 byte arg2 ;
12797 void *argp1 = 0 ;
12798 int res1 = 0 ;
12799 unsigned char val2 ;
12800 int ecode2 = 0 ;
12801 PyObject *swig_obj[2] ;
12802
12803 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12805 if (!SWIG_IsOK(res1)) {
12806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12807 }
12808 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12809 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12810 if (!SWIG_IsOK(ecode2)) {
12811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12812 }
12813 arg2 = static_cast< byte >(val2);
12814 if (arg1) (arg1)->blue = arg2;
12815
12816 resultobj = SWIG_Py_Void();
12817 return resultobj;
12818 fail:
12819 return NULL;
12820 }
12821
12822
12823 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12824 PyObject *resultobj = 0;
12825 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12826 byte result;
12827 void *argp1 = 0 ;
12828 int res1 = 0 ;
12829 PyObject *swig_obj[1] ;
12830
12831 if (!args) SWIG_fail;
12832 swig_obj[0] = args;
12833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12834 if (!SWIG_IsOK(res1)) {
12835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12836 }
12837 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12838 result = (byte) ((arg1)->blue);
12839 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12840 return resultobj;
12841 fail:
12842 return NULL;
12843 }
12844
12845
12846 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12847 PyObject *obj;
12848 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12849 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12850 return SWIG_Py_Void();
12851 }
12852
12853 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12854 return SWIG_Python_InitShadowInstance(args);
12855 }
12856
12857 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12858 PyObject *resultobj = 0;
12859 double arg1 = (double) 0.0 ;
12860 double arg2 = (double) 0.0 ;
12861 double arg3 = (double) 0.0 ;
12862 wxImage_HSVValue *result = 0 ;
12863 double val1 ;
12864 int ecode1 = 0 ;
12865 double val2 ;
12866 int ecode2 = 0 ;
12867 double val3 ;
12868 int ecode3 = 0 ;
12869 PyObject * obj0 = 0 ;
12870 PyObject * obj1 = 0 ;
12871 PyObject * obj2 = 0 ;
12872 char * kwnames[] = {
12873 (char *) "h",(char *) "s",(char *) "v", NULL
12874 };
12875
12876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12877 if (obj0) {
12878 ecode1 = SWIG_AsVal_double(obj0, &val1);
12879 if (!SWIG_IsOK(ecode1)) {
12880 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12881 }
12882 arg1 = static_cast< double >(val1);
12883 }
12884 if (obj1) {
12885 ecode2 = SWIG_AsVal_double(obj1, &val2);
12886 if (!SWIG_IsOK(ecode2)) {
12887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12888 }
12889 arg2 = static_cast< double >(val2);
12890 }
12891 if (obj2) {
12892 ecode3 = SWIG_AsVal_double(obj2, &val3);
12893 if (!SWIG_IsOK(ecode3)) {
12894 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12895 }
12896 arg3 = static_cast< double >(val3);
12897 }
12898 {
12899 PyThreadState* __tstate = wxPyBeginAllowThreads();
12900 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12901 wxPyEndAllowThreads(__tstate);
12902 if (PyErr_Occurred()) SWIG_fail;
12903 }
12904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12905 return resultobj;
12906 fail:
12907 return NULL;
12908 }
12909
12910
12911 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12912 PyObject *resultobj = 0;
12913 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12914 double arg2 ;
12915 void *argp1 = 0 ;
12916 int res1 = 0 ;
12917 double val2 ;
12918 int ecode2 = 0 ;
12919 PyObject *swig_obj[2] ;
12920
12921 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12923 if (!SWIG_IsOK(res1)) {
12924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12925 }
12926 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12927 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12928 if (!SWIG_IsOK(ecode2)) {
12929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12930 }
12931 arg2 = static_cast< double >(val2);
12932 if (arg1) (arg1)->hue = arg2;
12933
12934 resultobj = SWIG_Py_Void();
12935 return resultobj;
12936 fail:
12937 return NULL;
12938 }
12939
12940
12941 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12942 PyObject *resultobj = 0;
12943 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12944 double result;
12945 void *argp1 = 0 ;
12946 int res1 = 0 ;
12947 PyObject *swig_obj[1] ;
12948
12949 if (!args) SWIG_fail;
12950 swig_obj[0] = args;
12951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12952 if (!SWIG_IsOK(res1)) {
12953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12954 }
12955 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12956 result = (double) ((arg1)->hue);
12957 resultobj = SWIG_From_double(static_cast< double >(result));
12958 return resultobj;
12959 fail:
12960 return NULL;
12961 }
12962
12963
12964 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12965 PyObject *resultobj = 0;
12966 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12967 double arg2 ;
12968 void *argp1 = 0 ;
12969 int res1 = 0 ;
12970 double val2 ;
12971 int ecode2 = 0 ;
12972 PyObject *swig_obj[2] ;
12973
12974 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12976 if (!SWIG_IsOK(res1)) {
12977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12978 }
12979 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12980 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12981 if (!SWIG_IsOK(ecode2)) {
12982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12983 }
12984 arg2 = static_cast< double >(val2);
12985 if (arg1) (arg1)->saturation = arg2;
12986
12987 resultobj = SWIG_Py_Void();
12988 return resultobj;
12989 fail:
12990 return NULL;
12991 }
12992
12993
12994 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12995 PyObject *resultobj = 0;
12996 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12997 double result;
12998 void *argp1 = 0 ;
12999 int res1 = 0 ;
13000 PyObject *swig_obj[1] ;
13001
13002 if (!args) SWIG_fail;
13003 swig_obj[0] = args;
13004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13005 if (!SWIG_IsOK(res1)) {
13006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13007 }
13008 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13009 result = (double) ((arg1)->saturation);
13010 resultobj = SWIG_From_double(static_cast< double >(result));
13011 return resultobj;
13012 fail:
13013 return NULL;
13014 }
13015
13016
13017 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13018 PyObject *resultobj = 0;
13019 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13020 double arg2 ;
13021 void *argp1 = 0 ;
13022 int res1 = 0 ;
13023 double val2 ;
13024 int ecode2 = 0 ;
13025 PyObject *swig_obj[2] ;
13026
13027 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13029 if (!SWIG_IsOK(res1)) {
13030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13031 }
13032 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13033 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13034 if (!SWIG_IsOK(ecode2)) {
13035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13036 }
13037 arg2 = static_cast< double >(val2);
13038 if (arg1) (arg1)->value = arg2;
13039
13040 resultobj = SWIG_Py_Void();
13041 return resultobj;
13042 fail:
13043 return NULL;
13044 }
13045
13046
13047 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13048 PyObject *resultobj = 0;
13049 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13050 double result;
13051 void *argp1 = 0 ;
13052 int res1 = 0 ;
13053 PyObject *swig_obj[1] ;
13054
13055 if (!args) SWIG_fail;
13056 swig_obj[0] = args;
13057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13058 if (!SWIG_IsOK(res1)) {
13059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13060 }
13061 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13062 result = (double) ((arg1)->value);
13063 resultobj = SWIG_From_double(static_cast< double >(result));
13064 return resultobj;
13065 fail:
13066 return NULL;
13067 }
13068
13069
13070 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13071 PyObject *obj;
13072 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13073 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13074 return SWIG_Py_Void();
13075 }
13076
13077 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13078 return SWIG_Python_InitShadowInstance(args);
13079 }
13080
13081 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13082 PyObject *resultobj = 0;
13083 wxString *arg1 = 0 ;
13084 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13085 int arg3 = (int) -1 ;
13086 wxImage *result = 0 ;
13087 bool temp1 = false ;
13088 long val2 ;
13089 int ecode2 = 0 ;
13090 int val3 ;
13091 int ecode3 = 0 ;
13092 PyObject * obj0 = 0 ;
13093 PyObject * obj1 = 0 ;
13094 PyObject * obj2 = 0 ;
13095 char * kwnames[] = {
13096 (char *) "name",(char *) "type",(char *) "index", NULL
13097 };
13098
13099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13100 {
13101 arg1 = wxString_in_helper(obj0);
13102 if (arg1 == NULL) SWIG_fail;
13103 temp1 = true;
13104 }
13105 if (obj1) {
13106 ecode2 = SWIG_AsVal_long(obj1, &val2);
13107 if (!SWIG_IsOK(ecode2)) {
13108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13109 }
13110 arg2 = static_cast< long >(val2);
13111 }
13112 if (obj2) {
13113 ecode3 = SWIG_AsVal_int(obj2, &val3);
13114 if (!SWIG_IsOK(ecode3)) {
13115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13116 }
13117 arg3 = static_cast< int >(val3);
13118 }
13119 {
13120 PyThreadState* __tstate = wxPyBeginAllowThreads();
13121 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13122 wxPyEndAllowThreads(__tstate);
13123 if (PyErr_Occurred()) SWIG_fail;
13124 }
13125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13126 {
13127 if (temp1)
13128 delete arg1;
13129 }
13130 return resultobj;
13131 fail:
13132 {
13133 if (temp1)
13134 delete arg1;
13135 }
13136 return NULL;
13137 }
13138
13139
13140 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13141 PyObject *resultobj = 0;
13142 wxImage *arg1 = (wxImage *) 0 ;
13143 void *argp1 = 0 ;
13144 int res1 = 0 ;
13145 PyObject *swig_obj[1] ;
13146
13147 if (!args) SWIG_fail;
13148 swig_obj[0] = args;
13149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13150 if (!SWIG_IsOK(res1)) {
13151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13152 }
13153 arg1 = reinterpret_cast< wxImage * >(argp1);
13154 {
13155 PyThreadState* __tstate = wxPyBeginAllowThreads();
13156 delete arg1;
13157
13158 wxPyEndAllowThreads(__tstate);
13159 if (PyErr_Occurred()) SWIG_fail;
13160 }
13161 resultobj = SWIG_Py_Void();
13162 return resultobj;
13163 fail:
13164 return NULL;
13165 }
13166
13167
13168 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13169 PyObject *resultobj = 0;
13170 wxString *arg1 = 0 ;
13171 wxString *arg2 = 0 ;
13172 int arg3 = (int) -1 ;
13173 wxImage *result = 0 ;
13174 bool temp1 = false ;
13175 bool temp2 = false ;
13176 int val3 ;
13177 int ecode3 = 0 ;
13178 PyObject * obj0 = 0 ;
13179 PyObject * obj1 = 0 ;
13180 PyObject * obj2 = 0 ;
13181 char * kwnames[] = {
13182 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13183 };
13184
13185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13186 {
13187 arg1 = wxString_in_helper(obj0);
13188 if (arg1 == NULL) SWIG_fail;
13189 temp1 = true;
13190 }
13191 {
13192 arg2 = wxString_in_helper(obj1);
13193 if (arg2 == NULL) SWIG_fail;
13194 temp2 = true;
13195 }
13196 if (obj2) {
13197 ecode3 = SWIG_AsVal_int(obj2, &val3);
13198 if (!SWIG_IsOK(ecode3)) {
13199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13200 }
13201 arg3 = static_cast< int >(val3);
13202 }
13203 {
13204 PyThreadState* __tstate = wxPyBeginAllowThreads();
13205 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13206 wxPyEndAllowThreads(__tstate);
13207 if (PyErr_Occurred()) SWIG_fail;
13208 }
13209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13210 {
13211 if (temp1)
13212 delete arg1;
13213 }
13214 {
13215 if (temp2)
13216 delete arg2;
13217 }
13218 return resultobj;
13219 fail:
13220 {
13221 if (temp1)
13222 delete arg1;
13223 }
13224 {
13225 if (temp2)
13226 delete arg2;
13227 }
13228 return NULL;
13229 }
13230
13231
13232 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13233 PyObject *resultobj = 0;
13234 wxInputStream *arg1 = 0 ;
13235 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13236 int arg3 = (int) -1 ;
13237 wxImage *result = 0 ;
13238 wxPyInputStream *temp1 ;
13239 bool created1 ;
13240 long val2 ;
13241 int ecode2 = 0 ;
13242 int val3 ;
13243 int ecode3 = 0 ;
13244 PyObject * obj0 = 0 ;
13245 PyObject * obj1 = 0 ;
13246 PyObject * obj2 = 0 ;
13247 char * kwnames[] = {
13248 (char *) "stream",(char *) "type",(char *) "index", NULL
13249 };
13250
13251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13252 {
13253 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13254 arg1 = temp1->m_wxis;
13255 created1 = false;
13256 } else {
13257 PyErr_Clear(); // clear the failure of the wxPyConvert above
13258 arg1 = wxPyCBInputStream_create(obj0, false);
13259 if (arg1 == NULL) {
13260 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13261 SWIG_fail;
13262 }
13263 created1 = true;
13264 }
13265 }
13266 if (obj1) {
13267 ecode2 = SWIG_AsVal_long(obj1, &val2);
13268 if (!SWIG_IsOK(ecode2)) {
13269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13270 }
13271 arg2 = static_cast< long >(val2);
13272 }
13273 if (obj2) {
13274 ecode3 = SWIG_AsVal_int(obj2, &val3);
13275 if (!SWIG_IsOK(ecode3)) {
13276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13277 }
13278 arg3 = static_cast< int >(val3);
13279 }
13280 {
13281 PyThreadState* __tstate = wxPyBeginAllowThreads();
13282 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13283 wxPyEndAllowThreads(__tstate);
13284 if (PyErr_Occurred()) SWIG_fail;
13285 }
13286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13287 {
13288 if (created1) delete arg1;
13289 }
13290 return resultobj;
13291 fail:
13292 {
13293 if (created1) delete arg1;
13294 }
13295 return NULL;
13296 }
13297
13298
13299 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13300 PyObject *resultobj = 0;
13301 wxInputStream *arg1 = 0 ;
13302 wxString *arg2 = 0 ;
13303 int arg3 = (int) -1 ;
13304 wxImage *result = 0 ;
13305 wxPyInputStream *temp1 ;
13306 bool created1 ;
13307 bool temp2 = false ;
13308 int val3 ;
13309 int ecode3 = 0 ;
13310 PyObject * obj0 = 0 ;
13311 PyObject * obj1 = 0 ;
13312 PyObject * obj2 = 0 ;
13313 char * kwnames[] = {
13314 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13315 };
13316
13317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13318 {
13319 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13320 arg1 = temp1->m_wxis;
13321 created1 = false;
13322 } else {
13323 PyErr_Clear(); // clear the failure of the wxPyConvert above
13324 arg1 = wxPyCBInputStream_create(obj0, false);
13325 if (arg1 == NULL) {
13326 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13327 SWIG_fail;
13328 }
13329 created1 = true;
13330 }
13331 }
13332 {
13333 arg2 = wxString_in_helper(obj1);
13334 if (arg2 == NULL) SWIG_fail;
13335 temp2 = true;
13336 }
13337 if (obj2) {
13338 ecode3 = SWIG_AsVal_int(obj2, &val3);
13339 if (!SWIG_IsOK(ecode3)) {
13340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13341 }
13342 arg3 = static_cast< int >(val3);
13343 }
13344 {
13345 PyThreadState* __tstate = wxPyBeginAllowThreads();
13346 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13347 wxPyEndAllowThreads(__tstate);
13348 if (PyErr_Occurred()) SWIG_fail;
13349 }
13350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13351 {
13352 if (created1) delete arg1;
13353 }
13354 {
13355 if (temp2)
13356 delete arg2;
13357 }
13358 return resultobj;
13359 fail:
13360 {
13361 if (created1) delete arg1;
13362 }
13363 {
13364 if (temp2)
13365 delete arg2;
13366 }
13367 return NULL;
13368 }
13369
13370
13371 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13372 PyObject *resultobj = 0;
13373 int arg1 = (int) 0 ;
13374 int arg2 = (int) 0 ;
13375 bool arg3 = (bool) true ;
13376 wxImage *result = 0 ;
13377 int val1 ;
13378 int ecode1 = 0 ;
13379 int val2 ;
13380 int ecode2 = 0 ;
13381 bool val3 ;
13382 int ecode3 = 0 ;
13383 PyObject * obj0 = 0 ;
13384 PyObject * obj1 = 0 ;
13385 PyObject * obj2 = 0 ;
13386 char * kwnames[] = {
13387 (char *) "width",(char *) "height",(char *) "clear", NULL
13388 };
13389
13390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13391 if (obj0) {
13392 ecode1 = SWIG_AsVal_int(obj0, &val1);
13393 if (!SWIG_IsOK(ecode1)) {
13394 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13395 }
13396 arg1 = static_cast< int >(val1);
13397 }
13398 if (obj1) {
13399 ecode2 = SWIG_AsVal_int(obj1, &val2);
13400 if (!SWIG_IsOK(ecode2)) {
13401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13402 }
13403 arg2 = static_cast< int >(val2);
13404 }
13405 if (obj2) {
13406 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13407 if (!SWIG_IsOK(ecode3)) {
13408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13409 }
13410 arg3 = static_cast< bool >(val3);
13411 }
13412 {
13413 PyThreadState* __tstate = wxPyBeginAllowThreads();
13414 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13415 wxPyEndAllowThreads(__tstate);
13416 if (PyErr_Occurred()) SWIG_fail;
13417 }
13418 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13419 return resultobj;
13420 fail:
13421 return NULL;
13422 }
13423
13424
13425 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13426 PyObject *resultobj = 0;
13427 wxBitmap *arg1 = 0 ;
13428 wxImage *result = 0 ;
13429 void *argp1 = 0 ;
13430 int res1 = 0 ;
13431 PyObject * obj0 = 0 ;
13432 char * kwnames[] = {
13433 (char *) "bitmap", NULL
13434 };
13435
13436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13437 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13438 if (!SWIG_IsOK(res1)) {
13439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13440 }
13441 if (!argp1) {
13442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13443 }
13444 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13445 {
13446 if (!wxPyCheckForApp()) SWIG_fail;
13447 PyThreadState* __tstate = wxPyBeginAllowThreads();
13448 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13449 wxPyEndAllowThreads(__tstate);
13450 if (PyErr_Occurred()) SWIG_fail;
13451 }
13452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13453 return resultobj;
13454 fail:
13455 return NULL;
13456 }
13457
13458
13459 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13460 PyObject *resultobj = 0;
13461 int arg1 ;
13462 int arg2 ;
13463 buffer arg3 ;
13464 int arg4 ;
13465 wxImage *result = 0 ;
13466 int val1 ;
13467 int ecode1 = 0 ;
13468 int val2 ;
13469 int ecode2 = 0 ;
13470 Py_ssize_t temp3 ;
13471 PyObject * obj0 = 0 ;
13472 PyObject * obj1 = 0 ;
13473 PyObject * obj2 = 0 ;
13474 char * kwnames[] = {
13475 (char *) "width",(char *) "height",(char *) "data", NULL
13476 };
13477
13478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13479 ecode1 = SWIG_AsVal_int(obj0, &val1);
13480 if (!SWIG_IsOK(ecode1)) {
13481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13482 }
13483 arg1 = static_cast< int >(val1);
13484 ecode2 = SWIG_AsVal_int(obj1, &val2);
13485 if (!SWIG_IsOK(ecode2)) {
13486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13487 }
13488 arg2 = static_cast< int >(val2);
13489 {
13490 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13491 arg4 = (int)temp3;
13492 }
13493 {
13494 PyThreadState* __tstate = wxPyBeginAllowThreads();
13495 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13496 wxPyEndAllowThreads(__tstate);
13497 if (PyErr_Occurred()) SWIG_fail;
13498 }
13499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13500 return resultobj;
13501 fail:
13502 return NULL;
13503 }
13504
13505
13506 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13507 PyObject *resultobj = 0;
13508 int arg1 ;
13509 int arg2 ;
13510 buffer arg3 ;
13511 int arg4 ;
13512 buffer arg5 ;
13513 int arg6 ;
13514 wxImage *result = 0 ;
13515 int val1 ;
13516 int ecode1 = 0 ;
13517 int val2 ;
13518 int ecode2 = 0 ;
13519 Py_ssize_t temp3 ;
13520 Py_ssize_t temp5 ;
13521 PyObject * obj0 = 0 ;
13522 PyObject * obj1 = 0 ;
13523 PyObject * obj2 = 0 ;
13524 PyObject * obj3 = 0 ;
13525 char * kwnames[] = {
13526 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13527 };
13528
13529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13530 ecode1 = SWIG_AsVal_int(obj0, &val1);
13531 if (!SWIG_IsOK(ecode1)) {
13532 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13533 }
13534 arg1 = static_cast< int >(val1);
13535 ecode2 = SWIG_AsVal_int(obj1, &val2);
13536 if (!SWIG_IsOK(ecode2)) {
13537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13538 }
13539 arg2 = static_cast< int >(val2);
13540 {
13541 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13542 arg4 = (int)temp3;
13543 }
13544 {
13545 if (obj3 != Py_None) {
13546 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13547 arg6 = (int)temp5;
13548 }
13549 }
13550 {
13551 PyThreadState* __tstate = wxPyBeginAllowThreads();
13552 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13553 wxPyEndAllowThreads(__tstate);
13554 if (PyErr_Occurred()) SWIG_fail;
13555 }
13556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13557 return resultobj;
13558 fail:
13559 return NULL;
13560 }
13561
13562
13563 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13564 PyObject *resultobj = 0;
13565 wxImage *arg1 = (wxImage *) 0 ;
13566 int arg2 ;
13567 int arg3 ;
13568 bool arg4 = (bool) true ;
13569 void *argp1 = 0 ;
13570 int res1 = 0 ;
13571 int val2 ;
13572 int ecode2 = 0 ;
13573 int val3 ;
13574 int ecode3 = 0 ;
13575 bool val4 ;
13576 int ecode4 = 0 ;
13577 PyObject * obj0 = 0 ;
13578 PyObject * obj1 = 0 ;
13579 PyObject * obj2 = 0 ;
13580 PyObject * obj3 = 0 ;
13581 char * kwnames[] = {
13582 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13583 };
13584
13585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13587 if (!SWIG_IsOK(res1)) {
13588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13589 }
13590 arg1 = reinterpret_cast< wxImage * >(argp1);
13591 ecode2 = SWIG_AsVal_int(obj1, &val2);
13592 if (!SWIG_IsOK(ecode2)) {
13593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13594 }
13595 arg2 = static_cast< int >(val2);
13596 ecode3 = SWIG_AsVal_int(obj2, &val3);
13597 if (!SWIG_IsOK(ecode3)) {
13598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13599 }
13600 arg3 = static_cast< int >(val3);
13601 if (obj3) {
13602 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13603 if (!SWIG_IsOK(ecode4)) {
13604 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13605 }
13606 arg4 = static_cast< bool >(val4);
13607 }
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 (arg1)->Create(arg2,arg3,arg4);
13611 wxPyEndAllowThreads(__tstate);
13612 if (PyErr_Occurred()) SWIG_fail;
13613 }
13614 resultobj = SWIG_Py_Void();
13615 return resultobj;
13616 fail:
13617 return NULL;
13618 }
13619
13620
13621 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13622 PyObject *resultobj = 0;
13623 wxImage *arg1 = (wxImage *) 0 ;
13624 void *argp1 = 0 ;
13625 int res1 = 0 ;
13626 PyObject *swig_obj[1] ;
13627
13628 if (!args) SWIG_fail;
13629 swig_obj[0] = args;
13630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13631 if (!SWIG_IsOK(res1)) {
13632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13633 }
13634 arg1 = reinterpret_cast< wxImage * >(argp1);
13635 {
13636 PyThreadState* __tstate = wxPyBeginAllowThreads();
13637 (arg1)->Destroy();
13638 wxPyEndAllowThreads(__tstate);
13639 if (PyErr_Occurred()) SWIG_fail;
13640 }
13641 resultobj = SWIG_Py_Void();
13642 return resultobj;
13643 fail:
13644 return NULL;
13645 }
13646
13647
13648 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13649 PyObject *resultobj = 0;
13650 wxImage *arg1 = (wxImage *) 0 ;
13651 int arg2 ;
13652 int arg3 ;
13653 SwigValueWrapper<wxImage > result;
13654 void *argp1 = 0 ;
13655 int res1 = 0 ;
13656 int val2 ;
13657 int ecode2 = 0 ;
13658 int val3 ;
13659 int ecode3 = 0 ;
13660 PyObject * obj0 = 0 ;
13661 PyObject * obj1 = 0 ;
13662 PyObject * obj2 = 0 ;
13663 char * kwnames[] = {
13664 (char *) "self",(char *) "width",(char *) "height", NULL
13665 };
13666
13667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13669 if (!SWIG_IsOK(res1)) {
13670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13671 }
13672 arg1 = reinterpret_cast< wxImage * >(argp1);
13673 ecode2 = SWIG_AsVal_int(obj1, &val2);
13674 if (!SWIG_IsOK(ecode2)) {
13675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13676 }
13677 arg2 = static_cast< int >(val2);
13678 ecode3 = SWIG_AsVal_int(obj2, &val3);
13679 if (!SWIG_IsOK(ecode3)) {
13680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13681 }
13682 arg3 = static_cast< int >(val3);
13683 {
13684 PyThreadState* __tstate = wxPyBeginAllowThreads();
13685 result = (arg1)->Scale(arg2,arg3);
13686 wxPyEndAllowThreads(__tstate);
13687 if (PyErr_Occurred()) SWIG_fail;
13688 }
13689 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13690 return resultobj;
13691 fail:
13692 return NULL;
13693 }
13694
13695
13696 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13697 PyObject *resultobj = 0;
13698 wxImage *arg1 = (wxImage *) 0 ;
13699 int arg2 ;
13700 int arg3 ;
13701 SwigValueWrapper<wxImage > result;
13702 void *argp1 = 0 ;
13703 int res1 = 0 ;
13704 int val2 ;
13705 int ecode2 = 0 ;
13706 int val3 ;
13707 int ecode3 = 0 ;
13708 PyObject * obj0 = 0 ;
13709 PyObject * obj1 = 0 ;
13710 PyObject * obj2 = 0 ;
13711 char * kwnames[] = {
13712 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13713 };
13714
13715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13717 if (!SWIG_IsOK(res1)) {
13718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13719 }
13720 arg1 = reinterpret_cast< wxImage * >(argp1);
13721 ecode2 = SWIG_AsVal_int(obj1, &val2);
13722 if (!SWIG_IsOK(ecode2)) {
13723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13724 }
13725 arg2 = static_cast< int >(val2);
13726 ecode3 = SWIG_AsVal_int(obj2, &val3);
13727 if (!SWIG_IsOK(ecode3)) {
13728 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13729 }
13730 arg3 = static_cast< int >(val3);
13731 {
13732 PyThreadState* __tstate = wxPyBeginAllowThreads();
13733 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13734 wxPyEndAllowThreads(__tstate);
13735 if (PyErr_Occurred()) SWIG_fail;
13736 }
13737 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13738 return resultobj;
13739 fail:
13740 return NULL;
13741 }
13742
13743
13744 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13745 PyObject *resultobj = 0;
13746 wxImage *arg1 = (wxImage *) 0 ;
13747 int arg2 ;
13748 int arg3 ;
13749 wxImage *result = 0 ;
13750 void *argp1 = 0 ;
13751 int res1 = 0 ;
13752 int val2 ;
13753 int ecode2 = 0 ;
13754 int val3 ;
13755 int ecode3 = 0 ;
13756 PyObject * obj0 = 0 ;
13757 PyObject * obj1 = 0 ;
13758 PyObject * obj2 = 0 ;
13759 char * kwnames[] = {
13760 (char *) "self",(char *) "width",(char *) "height", NULL
13761 };
13762
13763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13765 if (!SWIG_IsOK(res1)) {
13766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13767 }
13768 arg1 = reinterpret_cast< wxImage * >(argp1);
13769 ecode2 = SWIG_AsVal_int(obj1, &val2);
13770 if (!SWIG_IsOK(ecode2)) {
13771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13772 }
13773 arg2 = static_cast< int >(val2);
13774 ecode3 = SWIG_AsVal_int(obj2, &val3);
13775 if (!SWIG_IsOK(ecode3)) {
13776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13777 }
13778 arg3 = static_cast< int >(val3);
13779 {
13780 PyThreadState* __tstate = wxPyBeginAllowThreads();
13781 {
13782 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13783 result = (wxImage *) &_result_ref;
13784 }
13785 wxPyEndAllowThreads(__tstate);
13786 if (PyErr_Occurred()) SWIG_fail;
13787 }
13788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13789 return resultobj;
13790 fail:
13791 return NULL;
13792 }
13793
13794
13795 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13796 PyObject *resultobj = 0;
13797 wxImage *arg1 = (wxImage *) 0 ;
13798 wxSize *arg2 = 0 ;
13799 wxPoint *arg3 = 0 ;
13800 int arg4 = (int) -1 ;
13801 int arg5 = (int) -1 ;
13802 int arg6 = (int) -1 ;
13803 wxImage *result = 0 ;
13804 void *argp1 = 0 ;
13805 int res1 = 0 ;
13806 wxSize temp2 ;
13807 wxPoint temp3 ;
13808 int val4 ;
13809 int ecode4 = 0 ;
13810 int val5 ;
13811 int ecode5 = 0 ;
13812 int val6 ;
13813 int ecode6 = 0 ;
13814 PyObject * obj0 = 0 ;
13815 PyObject * obj1 = 0 ;
13816 PyObject * obj2 = 0 ;
13817 PyObject * obj3 = 0 ;
13818 PyObject * obj4 = 0 ;
13819 PyObject * obj5 = 0 ;
13820 char * kwnames[] = {
13821 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13822 };
13823
13824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13826 if (!SWIG_IsOK(res1)) {
13827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13828 }
13829 arg1 = reinterpret_cast< wxImage * >(argp1);
13830 {
13831 arg2 = &temp2;
13832 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13833 }
13834 {
13835 arg3 = &temp3;
13836 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13837 }
13838 if (obj3) {
13839 ecode4 = SWIG_AsVal_int(obj3, &val4);
13840 if (!SWIG_IsOK(ecode4)) {
13841 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13842 }
13843 arg4 = static_cast< int >(val4);
13844 }
13845 if (obj4) {
13846 ecode5 = SWIG_AsVal_int(obj4, &val5);
13847 if (!SWIG_IsOK(ecode5)) {
13848 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13849 }
13850 arg5 = static_cast< int >(val5);
13851 }
13852 if (obj5) {
13853 ecode6 = SWIG_AsVal_int(obj5, &val6);
13854 if (!SWIG_IsOK(ecode6)) {
13855 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13856 }
13857 arg6 = static_cast< int >(val6);
13858 }
13859 {
13860 PyThreadState* __tstate = wxPyBeginAllowThreads();
13861 {
13862 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13863 result = (wxImage *) &_result_ref;
13864 }
13865 wxPyEndAllowThreads(__tstate);
13866 if (PyErr_Occurred()) SWIG_fail;
13867 }
13868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13869 return resultobj;
13870 fail:
13871 return NULL;
13872 }
13873
13874
13875 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13876 PyObject *resultobj = 0;
13877 wxImage *arg1 = (wxImage *) 0 ;
13878 int arg2 ;
13879 int arg3 ;
13880 byte arg4 ;
13881 byte arg5 ;
13882 byte arg6 ;
13883 void *argp1 = 0 ;
13884 int res1 = 0 ;
13885 int val2 ;
13886 int ecode2 = 0 ;
13887 int val3 ;
13888 int ecode3 = 0 ;
13889 unsigned char val4 ;
13890 int ecode4 = 0 ;
13891 unsigned char val5 ;
13892 int ecode5 = 0 ;
13893 unsigned char val6 ;
13894 int ecode6 = 0 ;
13895 PyObject * obj0 = 0 ;
13896 PyObject * obj1 = 0 ;
13897 PyObject * obj2 = 0 ;
13898 PyObject * obj3 = 0 ;
13899 PyObject * obj4 = 0 ;
13900 PyObject * obj5 = 0 ;
13901 char * kwnames[] = {
13902 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13903 };
13904
13905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13907 if (!SWIG_IsOK(res1)) {
13908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13909 }
13910 arg1 = reinterpret_cast< wxImage * >(argp1);
13911 ecode2 = SWIG_AsVal_int(obj1, &val2);
13912 if (!SWIG_IsOK(ecode2)) {
13913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13914 }
13915 arg2 = static_cast< int >(val2);
13916 ecode3 = SWIG_AsVal_int(obj2, &val3);
13917 if (!SWIG_IsOK(ecode3)) {
13918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13919 }
13920 arg3 = static_cast< int >(val3);
13921 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13922 if (!SWIG_IsOK(ecode4)) {
13923 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13924 }
13925 arg4 = static_cast< byte >(val4);
13926 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13927 if (!SWIG_IsOK(ecode5)) {
13928 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13929 }
13930 arg5 = static_cast< byte >(val5);
13931 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13932 if (!SWIG_IsOK(ecode6)) {
13933 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13934 }
13935 arg6 = static_cast< byte >(val6);
13936 {
13937 PyThreadState* __tstate = wxPyBeginAllowThreads();
13938 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13939 wxPyEndAllowThreads(__tstate);
13940 if (PyErr_Occurred()) SWIG_fail;
13941 }
13942 resultobj = SWIG_Py_Void();
13943 return resultobj;
13944 fail:
13945 return NULL;
13946 }
13947
13948
13949 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13950 PyObject *resultobj = 0;
13951 wxImage *arg1 = (wxImage *) 0 ;
13952 wxRect *arg2 = 0 ;
13953 byte arg3 ;
13954 byte arg4 ;
13955 byte arg5 ;
13956 void *argp1 = 0 ;
13957 int res1 = 0 ;
13958 wxRect temp2 ;
13959 unsigned char val3 ;
13960 int ecode3 = 0 ;
13961 unsigned char val4 ;
13962 int ecode4 = 0 ;
13963 unsigned char val5 ;
13964 int ecode5 = 0 ;
13965 PyObject * obj0 = 0 ;
13966 PyObject * obj1 = 0 ;
13967 PyObject * obj2 = 0 ;
13968 PyObject * obj3 = 0 ;
13969 PyObject * obj4 = 0 ;
13970 char * kwnames[] = {
13971 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13972 };
13973
13974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13976 if (!SWIG_IsOK(res1)) {
13977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13978 }
13979 arg1 = reinterpret_cast< wxImage * >(argp1);
13980 {
13981 arg2 = &temp2;
13982 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13983 }
13984 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13985 if (!SWIG_IsOK(ecode3)) {
13986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13987 }
13988 arg3 = static_cast< byte >(val3);
13989 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13990 if (!SWIG_IsOK(ecode4)) {
13991 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13992 }
13993 arg4 = static_cast< byte >(val4);
13994 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13995 if (!SWIG_IsOK(ecode5)) {
13996 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13997 }
13998 arg5 = static_cast< byte >(val5);
13999 {
14000 PyThreadState* __tstate = wxPyBeginAllowThreads();
14001 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14002 wxPyEndAllowThreads(__tstate);
14003 if (PyErr_Occurred()) SWIG_fail;
14004 }
14005 resultobj = SWIG_Py_Void();
14006 return resultobj;
14007 fail:
14008 return NULL;
14009 }
14010
14011
14012 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14013 PyObject *resultobj = 0;
14014 wxImage *arg1 = (wxImage *) 0 ;
14015 int arg2 ;
14016 int arg3 ;
14017 byte result;
14018 void *argp1 = 0 ;
14019 int res1 = 0 ;
14020 int val2 ;
14021 int ecode2 = 0 ;
14022 int val3 ;
14023 int ecode3 = 0 ;
14024 PyObject * obj0 = 0 ;
14025 PyObject * obj1 = 0 ;
14026 PyObject * obj2 = 0 ;
14027 char * kwnames[] = {
14028 (char *) "self",(char *) "x",(char *) "y", NULL
14029 };
14030
14031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14033 if (!SWIG_IsOK(res1)) {
14034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14035 }
14036 arg1 = reinterpret_cast< wxImage * >(argp1);
14037 ecode2 = SWIG_AsVal_int(obj1, &val2);
14038 if (!SWIG_IsOK(ecode2)) {
14039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14040 }
14041 arg2 = static_cast< int >(val2);
14042 ecode3 = SWIG_AsVal_int(obj2, &val3);
14043 if (!SWIG_IsOK(ecode3)) {
14044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14045 }
14046 arg3 = static_cast< int >(val3);
14047 {
14048 PyThreadState* __tstate = wxPyBeginAllowThreads();
14049 result = (byte)(arg1)->GetRed(arg2,arg3);
14050 wxPyEndAllowThreads(__tstate);
14051 if (PyErr_Occurred()) SWIG_fail;
14052 }
14053 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14054 return resultobj;
14055 fail:
14056 return NULL;
14057 }
14058
14059
14060 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14061 PyObject *resultobj = 0;
14062 wxImage *arg1 = (wxImage *) 0 ;
14063 int arg2 ;
14064 int arg3 ;
14065 byte result;
14066 void *argp1 = 0 ;
14067 int res1 = 0 ;
14068 int val2 ;
14069 int ecode2 = 0 ;
14070 int val3 ;
14071 int ecode3 = 0 ;
14072 PyObject * obj0 = 0 ;
14073 PyObject * obj1 = 0 ;
14074 PyObject * obj2 = 0 ;
14075 char * kwnames[] = {
14076 (char *) "self",(char *) "x",(char *) "y", NULL
14077 };
14078
14079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14081 if (!SWIG_IsOK(res1)) {
14082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14083 }
14084 arg1 = reinterpret_cast< wxImage * >(argp1);
14085 ecode2 = SWIG_AsVal_int(obj1, &val2);
14086 if (!SWIG_IsOK(ecode2)) {
14087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14088 }
14089 arg2 = static_cast< int >(val2);
14090 ecode3 = SWIG_AsVal_int(obj2, &val3);
14091 if (!SWIG_IsOK(ecode3)) {
14092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14093 }
14094 arg3 = static_cast< int >(val3);
14095 {
14096 PyThreadState* __tstate = wxPyBeginAllowThreads();
14097 result = (byte)(arg1)->GetGreen(arg2,arg3);
14098 wxPyEndAllowThreads(__tstate);
14099 if (PyErr_Occurred()) SWIG_fail;
14100 }
14101 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14102 return resultobj;
14103 fail:
14104 return NULL;
14105 }
14106
14107
14108 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14109 PyObject *resultobj = 0;
14110 wxImage *arg1 = (wxImage *) 0 ;
14111 int arg2 ;
14112 int arg3 ;
14113 byte result;
14114 void *argp1 = 0 ;
14115 int res1 = 0 ;
14116 int val2 ;
14117 int ecode2 = 0 ;
14118 int val3 ;
14119 int ecode3 = 0 ;
14120 PyObject * obj0 = 0 ;
14121 PyObject * obj1 = 0 ;
14122 PyObject * obj2 = 0 ;
14123 char * kwnames[] = {
14124 (char *) "self",(char *) "x",(char *) "y", NULL
14125 };
14126
14127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14129 if (!SWIG_IsOK(res1)) {
14130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14131 }
14132 arg1 = reinterpret_cast< wxImage * >(argp1);
14133 ecode2 = SWIG_AsVal_int(obj1, &val2);
14134 if (!SWIG_IsOK(ecode2)) {
14135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14136 }
14137 arg2 = static_cast< int >(val2);
14138 ecode3 = SWIG_AsVal_int(obj2, &val3);
14139 if (!SWIG_IsOK(ecode3)) {
14140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14141 }
14142 arg3 = static_cast< int >(val3);
14143 {
14144 PyThreadState* __tstate = wxPyBeginAllowThreads();
14145 result = (byte)(arg1)->GetBlue(arg2,arg3);
14146 wxPyEndAllowThreads(__tstate);
14147 if (PyErr_Occurred()) SWIG_fail;
14148 }
14149 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14150 return resultobj;
14151 fail:
14152 return NULL;
14153 }
14154
14155
14156 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14157 PyObject *resultobj = 0;
14158 wxImage *arg1 = (wxImage *) 0 ;
14159 int arg2 ;
14160 int arg3 ;
14161 byte arg4 ;
14162 void *argp1 = 0 ;
14163 int res1 = 0 ;
14164 int val2 ;
14165 int ecode2 = 0 ;
14166 int val3 ;
14167 int ecode3 = 0 ;
14168 unsigned char val4 ;
14169 int ecode4 = 0 ;
14170 PyObject * obj0 = 0 ;
14171 PyObject * obj1 = 0 ;
14172 PyObject * obj2 = 0 ;
14173 PyObject * obj3 = 0 ;
14174 char * kwnames[] = {
14175 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14176 };
14177
14178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14180 if (!SWIG_IsOK(res1)) {
14181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14182 }
14183 arg1 = reinterpret_cast< wxImage * >(argp1);
14184 ecode2 = SWIG_AsVal_int(obj1, &val2);
14185 if (!SWIG_IsOK(ecode2)) {
14186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14187 }
14188 arg2 = static_cast< int >(val2);
14189 ecode3 = SWIG_AsVal_int(obj2, &val3);
14190 if (!SWIG_IsOK(ecode3)) {
14191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14192 }
14193 arg3 = static_cast< int >(val3);
14194 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14195 if (!SWIG_IsOK(ecode4)) {
14196 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14197 }
14198 arg4 = static_cast< byte >(val4);
14199 {
14200 PyThreadState* __tstate = wxPyBeginAllowThreads();
14201 (arg1)->SetAlpha(arg2,arg3,arg4);
14202 wxPyEndAllowThreads(__tstate);
14203 if (PyErr_Occurred()) SWIG_fail;
14204 }
14205 resultobj = SWIG_Py_Void();
14206 return resultobj;
14207 fail:
14208 return NULL;
14209 }
14210
14211
14212 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14213 PyObject *resultobj = 0;
14214 wxImage *arg1 = (wxImage *) 0 ;
14215 int arg2 ;
14216 int arg3 ;
14217 byte result;
14218 void *argp1 = 0 ;
14219 int res1 = 0 ;
14220 int val2 ;
14221 int ecode2 = 0 ;
14222 int val3 ;
14223 int ecode3 = 0 ;
14224 PyObject * obj0 = 0 ;
14225 PyObject * obj1 = 0 ;
14226 PyObject * obj2 = 0 ;
14227 char * kwnames[] = {
14228 (char *) "self",(char *) "x",(char *) "y", NULL
14229 };
14230
14231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14233 if (!SWIG_IsOK(res1)) {
14234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14235 }
14236 arg1 = reinterpret_cast< wxImage * >(argp1);
14237 ecode2 = SWIG_AsVal_int(obj1, &val2);
14238 if (!SWIG_IsOK(ecode2)) {
14239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14240 }
14241 arg2 = static_cast< int >(val2);
14242 ecode3 = SWIG_AsVal_int(obj2, &val3);
14243 if (!SWIG_IsOK(ecode3)) {
14244 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14245 }
14246 arg3 = static_cast< int >(val3);
14247 {
14248 PyThreadState* __tstate = wxPyBeginAllowThreads();
14249 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14250 wxPyEndAllowThreads(__tstate);
14251 if (PyErr_Occurred()) SWIG_fail;
14252 }
14253 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14254 return resultobj;
14255 fail:
14256 return NULL;
14257 }
14258
14259
14260 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14261 PyObject *resultobj = 0;
14262 wxImage *arg1 = (wxImage *) 0 ;
14263 bool result;
14264 void *argp1 = 0 ;
14265 int res1 = 0 ;
14266 PyObject *swig_obj[1] ;
14267
14268 if (!args) SWIG_fail;
14269 swig_obj[0] = args;
14270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14271 if (!SWIG_IsOK(res1)) {
14272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14273 }
14274 arg1 = reinterpret_cast< wxImage * >(argp1);
14275 {
14276 PyThreadState* __tstate = wxPyBeginAllowThreads();
14277 result = (bool)(arg1)->HasAlpha();
14278 wxPyEndAllowThreads(__tstate);
14279 if (PyErr_Occurred()) SWIG_fail;
14280 }
14281 {
14282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14283 }
14284 return resultobj;
14285 fail:
14286 return NULL;
14287 }
14288
14289
14290 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14291 PyObject *resultobj = 0;
14292 wxImage *arg1 = (wxImage *) 0 ;
14293 void *argp1 = 0 ;
14294 int res1 = 0 ;
14295 PyObject *swig_obj[1] ;
14296
14297 if (!args) SWIG_fail;
14298 swig_obj[0] = args;
14299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14300 if (!SWIG_IsOK(res1)) {
14301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14302 }
14303 arg1 = reinterpret_cast< wxImage * >(argp1);
14304 {
14305 PyThreadState* __tstate = wxPyBeginAllowThreads();
14306 (arg1)->InitAlpha();
14307 wxPyEndAllowThreads(__tstate);
14308 if (PyErr_Occurred()) SWIG_fail;
14309 }
14310 resultobj = SWIG_Py_Void();
14311 return resultobj;
14312 fail:
14313 return NULL;
14314 }
14315
14316
14317 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14318 PyObject *resultobj = 0;
14319 wxImage *arg1 = (wxImage *) 0 ;
14320 int arg2 ;
14321 int arg3 ;
14322 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14323 bool result;
14324 void *argp1 = 0 ;
14325 int res1 = 0 ;
14326 int val2 ;
14327 int ecode2 = 0 ;
14328 int val3 ;
14329 int ecode3 = 0 ;
14330 unsigned char val4 ;
14331 int ecode4 = 0 ;
14332 PyObject * obj0 = 0 ;
14333 PyObject * obj1 = 0 ;
14334 PyObject * obj2 = 0 ;
14335 PyObject * obj3 = 0 ;
14336 char * kwnames[] = {
14337 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14338 };
14339
14340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14342 if (!SWIG_IsOK(res1)) {
14343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14344 }
14345 arg1 = reinterpret_cast< wxImage * >(argp1);
14346 ecode2 = SWIG_AsVal_int(obj1, &val2);
14347 if (!SWIG_IsOK(ecode2)) {
14348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14349 }
14350 arg2 = static_cast< int >(val2);
14351 ecode3 = SWIG_AsVal_int(obj2, &val3);
14352 if (!SWIG_IsOK(ecode3)) {
14353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14354 }
14355 arg3 = static_cast< int >(val3);
14356 if (obj3) {
14357 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14358 if (!SWIG_IsOK(ecode4)) {
14359 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14360 }
14361 arg4 = static_cast< byte >(val4);
14362 }
14363 {
14364 PyThreadState* __tstate = wxPyBeginAllowThreads();
14365 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14366 wxPyEndAllowThreads(__tstate);
14367 if (PyErr_Occurred()) SWIG_fail;
14368 }
14369 {
14370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14371 }
14372 return resultobj;
14373 fail:
14374 return NULL;
14375 }
14376
14377
14378 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14379 PyObject *resultobj = 0;
14380 wxImage *arg1 = (wxImage *) 0 ;
14381 byte *arg2 = (byte *) 0 ;
14382 byte *arg3 = (byte *) 0 ;
14383 byte *arg4 = (byte *) 0 ;
14384 byte arg5 = (byte) 0 ;
14385 byte arg6 = (byte) 0 ;
14386 byte arg7 = (byte) 0 ;
14387 bool result;
14388 void *argp1 = 0 ;
14389 int res1 = 0 ;
14390 byte temp2 ;
14391 int res2 = SWIG_TMPOBJ ;
14392 byte temp3 ;
14393 int res3 = SWIG_TMPOBJ ;
14394 byte temp4 ;
14395 int res4 = SWIG_TMPOBJ ;
14396 unsigned char val5 ;
14397 int ecode5 = 0 ;
14398 unsigned char val6 ;
14399 int ecode6 = 0 ;
14400 unsigned char val7 ;
14401 int ecode7 = 0 ;
14402 PyObject * obj0 = 0 ;
14403 PyObject * obj1 = 0 ;
14404 PyObject * obj2 = 0 ;
14405 PyObject * obj3 = 0 ;
14406 char * kwnames[] = {
14407 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14408 };
14409
14410 arg2 = &temp2;
14411 arg3 = &temp3;
14412 arg4 = &temp4;
14413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14415 if (!SWIG_IsOK(res1)) {
14416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14417 }
14418 arg1 = reinterpret_cast< wxImage * >(argp1);
14419 if (obj1) {
14420 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14421 if (!SWIG_IsOK(ecode5)) {
14422 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14423 }
14424 arg5 = static_cast< byte >(val5);
14425 }
14426 if (obj2) {
14427 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14428 if (!SWIG_IsOK(ecode6)) {
14429 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14430 }
14431 arg6 = static_cast< byte >(val6);
14432 }
14433 if (obj3) {
14434 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14435 if (!SWIG_IsOK(ecode7)) {
14436 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14437 }
14438 arg7 = static_cast< byte >(val7);
14439 }
14440 {
14441 PyThreadState* __tstate = wxPyBeginAllowThreads();
14442 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14443 wxPyEndAllowThreads(__tstate);
14444 if (PyErr_Occurred()) SWIG_fail;
14445 }
14446 {
14447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14448 }
14449 if (SWIG_IsTmpObj(res2)) {
14450 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14451 } else {
14452 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14453 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14454 }
14455 if (SWIG_IsTmpObj(res3)) {
14456 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14457 } else {
14458 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14459 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14460 }
14461 if (SWIG_IsTmpObj(res4)) {
14462 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14463 } else {
14464 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14465 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14466 }
14467 return resultobj;
14468 fail:
14469 return NULL;
14470 }
14471
14472
14473 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14474 PyObject *resultobj = 0;
14475 wxImage *arg1 = (wxImage *) 0 ;
14476 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14477 bool result;
14478 void *argp1 = 0 ;
14479 int res1 = 0 ;
14480 unsigned char val2 ;
14481 int ecode2 = 0 ;
14482 PyObject * obj0 = 0 ;
14483 PyObject * obj1 = 0 ;
14484 char * kwnames[] = {
14485 (char *) "self",(char *) "threshold", NULL
14486 };
14487
14488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14490 if (!SWIG_IsOK(res1)) {
14491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14492 }
14493 arg1 = reinterpret_cast< wxImage * >(argp1);
14494 if (obj1) {
14495 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14496 if (!SWIG_IsOK(ecode2)) {
14497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14498 }
14499 arg2 = static_cast< byte >(val2);
14500 }
14501 {
14502 PyThreadState* __tstate = wxPyBeginAllowThreads();
14503 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14504 wxPyEndAllowThreads(__tstate);
14505 if (PyErr_Occurred()) SWIG_fail;
14506 }
14507 {
14508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14509 }
14510 return resultobj;
14511 fail:
14512 return NULL;
14513 }
14514
14515
14516 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14517 PyObject *resultobj = 0;
14518 wxImage *arg1 = (wxImage *) 0 ;
14519 byte arg2 ;
14520 byte arg3 ;
14521 byte arg4 ;
14522 bool result;
14523 void *argp1 = 0 ;
14524 int res1 = 0 ;
14525 unsigned char val2 ;
14526 int ecode2 = 0 ;
14527 unsigned char val3 ;
14528 int ecode3 = 0 ;
14529 unsigned char val4 ;
14530 int ecode4 = 0 ;
14531 PyObject * obj0 = 0 ;
14532 PyObject * obj1 = 0 ;
14533 PyObject * obj2 = 0 ;
14534 PyObject * obj3 = 0 ;
14535 char * kwnames[] = {
14536 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14537 };
14538
14539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14541 if (!SWIG_IsOK(res1)) {
14542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14543 }
14544 arg1 = reinterpret_cast< wxImage * >(argp1);
14545 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14546 if (!SWIG_IsOK(ecode2)) {
14547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14548 }
14549 arg2 = static_cast< byte >(val2);
14550 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14551 if (!SWIG_IsOK(ecode3)) {
14552 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14553 }
14554 arg3 = static_cast< byte >(val3);
14555 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14556 if (!SWIG_IsOK(ecode4)) {
14557 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14558 }
14559 arg4 = static_cast< byte >(val4);
14560 {
14561 PyThreadState* __tstate = wxPyBeginAllowThreads();
14562 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14563 wxPyEndAllowThreads(__tstate);
14564 if (PyErr_Occurred()) SWIG_fail;
14565 }
14566 {
14567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14568 }
14569 return resultobj;
14570 fail:
14571 return NULL;
14572 }
14573
14574
14575 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14576 PyObject *resultobj = 0;
14577 wxImage *arg1 = (wxImage *) 0 ;
14578 wxImage *arg2 = 0 ;
14579 byte arg3 ;
14580 byte arg4 ;
14581 byte arg5 ;
14582 bool result;
14583 void *argp1 = 0 ;
14584 int res1 = 0 ;
14585 void *argp2 = 0 ;
14586 int res2 = 0 ;
14587 unsigned char val3 ;
14588 int ecode3 = 0 ;
14589 unsigned char val4 ;
14590 int ecode4 = 0 ;
14591 unsigned char val5 ;
14592 int ecode5 = 0 ;
14593 PyObject * obj0 = 0 ;
14594 PyObject * obj1 = 0 ;
14595 PyObject * obj2 = 0 ;
14596 PyObject * obj3 = 0 ;
14597 PyObject * obj4 = 0 ;
14598 char * kwnames[] = {
14599 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14600 };
14601
14602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14604 if (!SWIG_IsOK(res1)) {
14605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14606 }
14607 arg1 = reinterpret_cast< wxImage * >(argp1);
14608 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14609 if (!SWIG_IsOK(res2)) {
14610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14611 }
14612 if (!argp2) {
14613 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14614 }
14615 arg2 = reinterpret_cast< wxImage * >(argp2);
14616 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14617 if (!SWIG_IsOK(ecode3)) {
14618 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14619 }
14620 arg3 = static_cast< byte >(val3);
14621 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14622 if (!SWIG_IsOK(ecode4)) {
14623 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14624 }
14625 arg4 = static_cast< byte >(val4);
14626 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14627 if (!SWIG_IsOK(ecode5)) {
14628 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14629 }
14630 arg5 = static_cast< byte >(val5);
14631 {
14632 PyThreadState* __tstate = wxPyBeginAllowThreads();
14633 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14634 wxPyEndAllowThreads(__tstate);
14635 if (PyErr_Occurred()) SWIG_fail;
14636 }
14637 {
14638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14639 }
14640 return resultobj;
14641 fail:
14642 return NULL;
14643 }
14644
14645
14646 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14647 PyObject *resultobj = 0;
14648 wxString *arg1 = 0 ;
14649 bool result;
14650 bool temp1 = false ;
14651 PyObject * obj0 = 0 ;
14652 char * kwnames[] = {
14653 (char *) "filename", NULL
14654 };
14655
14656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14657 {
14658 arg1 = wxString_in_helper(obj0);
14659 if (arg1 == NULL) SWIG_fail;
14660 temp1 = true;
14661 }
14662 {
14663 PyThreadState* __tstate = wxPyBeginAllowThreads();
14664 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14665 wxPyEndAllowThreads(__tstate);
14666 if (PyErr_Occurred()) SWIG_fail;
14667 }
14668 {
14669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14670 }
14671 {
14672 if (temp1)
14673 delete arg1;
14674 }
14675 return resultobj;
14676 fail:
14677 {
14678 if (temp1)
14679 delete arg1;
14680 }
14681 return NULL;
14682 }
14683
14684
14685 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14686 PyObject *resultobj = 0;
14687 wxString *arg1 = 0 ;
14688 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14689 int result;
14690 bool temp1 = false ;
14691 long val2 ;
14692 int ecode2 = 0 ;
14693 PyObject * obj0 = 0 ;
14694 PyObject * obj1 = 0 ;
14695 char * kwnames[] = {
14696 (char *) "filename",(char *) "type", NULL
14697 };
14698
14699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14700 {
14701 arg1 = wxString_in_helper(obj0);
14702 if (arg1 == NULL) SWIG_fail;
14703 temp1 = true;
14704 }
14705 if (obj1) {
14706 ecode2 = SWIG_AsVal_long(obj1, &val2);
14707 if (!SWIG_IsOK(ecode2)) {
14708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14709 }
14710 arg2 = static_cast< long >(val2);
14711 }
14712 {
14713 PyThreadState* __tstate = wxPyBeginAllowThreads();
14714 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14715 wxPyEndAllowThreads(__tstate);
14716 if (PyErr_Occurred()) SWIG_fail;
14717 }
14718 resultobj = SWIG_From_int(static_cast< int >(result));
14719 {
14720 if (temp1)
14721 delete arg1;
14722 }
14723 return resultobj;
14724 fail:
14725 {
14726 if (temp1)
14727 delete arg1;
14728 }
14729 return NULL;
14730 }
14731
14732
14733 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14734 PyObject *resultobj = 0;
14735 wxImage *arg1 = (wxImage *) 0 ;
14736 wxString *arg2 = 0 ;
14737 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14738 int arg4 = (int) -1 ;
14739 bool result;
14740 void *argp1 = 0 ;
14741 int res1 = 0 ;
14742 bool temp2 = false ;
14743 long val3 ;
14744 int ecode3 = 0 ;
14745 int val4 ;
14746 int ecode4 = 0 ;
14747 PyObject * obj0 = 0 ;
14748 PyObject * obj1 = 0 ;
14749 PyObject * obj2 = 0 ;
14750 PyObject * obj3 = 0 ;
14751 char * kwnames[] = {
14752 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14753 };
14754
14755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14757 if (!SWIG_IsOK(res1)) {
14758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14759 }
14760 arg1 = reinterpret_cast< wxImage * >(argp1);
14761 {
14762 arg2 = wxString_in_helper(obj1);
14763 if (arg2 == NULL) SWIG_fail;
14764 temp2 = true;
14765 }
14766 if (obj2) {
14767 ecode3 = SWIG_AsVal_long(obj2, &val3);
14768 if (!SWIG_IsOK(ecode3)) {
14769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14770 }
14771 arg3 = static_cast< long >(val3);
14772 }
14773 if (obj3) {
14774 ecode4 = SWIG_AsVal_int(obj3, &val4);
14775 if (!SWIG_IsOK(ecode4)) {
14776 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14777 }
14778 arg4 = static_cast< int >(val4);
14779 }
14780 {
14781 PyThreadState* __tstate = wxPyBeginAllowThreads();
14782 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14783 wxPyEndAllowThreads(__tstate);
14784 if (PyErr_Occurred()) SWIG_fail;
14785 }
14786 {
14787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14788 }
14789 {
14790 if (temp2)
14791 delete arg2;
14792 }
14793 return resultobj;
14794 fail:
14795 {
14796 if (temp2)
14797 delete arg2;
14798 }
14799 return NULL;
14800 }
14801
14802
14803 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14804 PyObject *resultobj = 0;
14805 wxImage *arg1 = (wxImage *) 0 ;
14806 wxString *arg2 = 0 ;
14807 wxString *arg3 = 0 ;
14808 int arg4 = (int) -1 ;
14809 bool result;
14810 void *argp1 = 0 ;
14811 int res1 = 0 ;
14812 bool temp2 = false ;
14813 bool temp3 = false ;
14814 int val4 ;
14815 int ecode4 = 0 ;
14816 PyObject * obj0 = 0 ;
14817 PyObject * obj1 = 0 ;
14818 PyObject * obj2 = 0 ;
14819 PyObject * obj3 = 0 ;
14820 char * kwnames[] = {
14821 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14822 };
14823
14824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14826 if (!SWIG_IsOK(res1)) {
14827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14828 }
14829 arg1 = reinterpret_cast< wxImage * >(argp1);
14830 {
14831 arg2 = wxString_in_helper(obj1);
14832 if (arg2 == NULL) SWIG_fail;
14833 temp2 = true;
14834 }
14835 {
14836 arg3 = wxString_in_helper(obj2);
14837 if (arg3 == NULL) SWIG_fail;
14838 temp3 = true;
14839 }
14840 if (obj3) {
14841 ecode4 = SWIG_AsVal_int(obj3, &val4);
14842 if (!SWIG_IsOK(ecode4)) {
14843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14844 }
14845 arg4 = static_cast< int >(val4);
14846 }
14847 {
14848 PyThreadState* __tstate = wxPyBeginAllowThreads();
14849 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14850 wxPyEndAllowThreads(__tstate);
14851 if (PyErr_Occurred()) SWIG_fail;
14852 }
14853 {
14854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14855 }
14856 {
14857 if (temp2)
14858 delete arg2;
14859 }
14860 {
14861 if (temp3)
14862 delete arg3;
14863 }
14864 return resultobj;
14865 fail:
14866 {
14867 if (temp2)
14868 delete arg2;
14869 }
14870 {
14871 if (temp3)
14872 delete arg3;
14873 }
14874 return NULL;
14875 }
14876
14877
14878 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14879 PyObject *resultobj = 0;
14880 wxImage *arg1 = (wxImage *) 0 ;
14881 wxString *arg2 = 0 ;
14882 int arg3 ;
14883 bool result;
14884 void *argp1 = 0 ;
14885 int res1 = 0 ;
14886 bool temp2 = false ;
14887 int val3 ;
14888 int ecode3 = 0 ;
14889 PyObject * obj0 = 0 ;
14890 PyObject * obj1 = 0 ;
14891 PyObject * obj2 = 0 ;
14892 char * kwnames[] = {
14893 (char *) "self",(char *) "name",(char *) "type", NULL
14894 };
14895
14896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14898 if (!SWIG_IsOK(res1)) {
14899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14900 }
14901 arg1 = reinterpret_cast< wxImage * >(argp1);
14902 {
14903 arg2 = wxString_in_helper(obj1);
14904 if (arg2 == NULL) SWIG_fail;
14905 temp2 = true;
14906 }
14907 ecode3 = SWIG_AsVal_int(obj2, &val3);
14908 if (!SWIG_IsOK(ecode3)) {
14909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14910 }
14911 arg3 = static_cast< int >(val3);
14912 {
14913 PyThreadState* __tstate = wxPyBeginAllowThreads();
14914 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14915 wxPyEndAllowThreads(__tstate);
14916 if (PyErr_Occurred()) SWIG_fail;
14917 }
14918 {
14919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14920 }
14921 {
14922 if (temp2)
14923 delete arg2;
14924 }
14925 return resultobj;
14926 fail:
14927 {
14928 if (temp2)
14929 delete arg2;
14930 }
14931 return NULL;
14932 }
14933
14934
14935 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14936 PyObject *resultobj = 0;
14937 wxImage *arg1 = (wxImage *) 0 ;
14938 wxString *arg2 = 0 ;
14939 wxString *arg3 = 0 ;
14940 bool result;
14941 void *argp1 = 0 ;
14942 int res1 = 0 ;
14943 bool temp2 = false ;
14944 bool temp3 = false ;
14945 PyObject * obj0 = 0 ;
14946 PyObject * obj1 = 0 ;
14947 PyObject * obj2 = 0 ;
14948 char * kwnames[] = {
14949 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14950 };
14951
14952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14954 if (!SWIG_IsOK(res1)) {
14955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14956 }
14957 arg1 = reinterpret_cast< wxImage * >(argp1);
14958 {
14959 arg2 = wxString_in_helper(obj1);
14960 if (arg2 == NULL) SWIG_fail;
14961 temp2 = true;
14962 }
14963 {
14964 arg3 = wxString_in_helper(obj2);
14965 if (arg3 == NULL) SWIG_fail;
14966 temp3 = true;
14967 }
14968 {
14969 PyThreadState* __tstate = wxPyBeginAllowThreads();
14970 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14971 wxPyEndAllowThreads(__tstate);
14972 if (PyErr_Occurred()) SWIG_fail;
14973 }
14974 {
14975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14976 }
14977 {
14978 if (temp2)
14979 delete arg2;
14980 }
14981 {
14982 if (temp3)
14983 delete arg3;
14984 }
14985 return resultobj;
14986 fail:
14987 {
14988 if (temp2)
14989 delete arg2;
14990 }
14991 {
14992 if (temp3)
14993 delete arg3;
14994 }
14995 return NULL;
14996 }
14997
14998
14999 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15000 PyObject *resultobj = 0;
15001 wxInputStream *arg1 = 0 ;
15002 bool result;
15003 wxPyInputStream *temp1 ;
15004 bool created1 ;
15005 PyObject * obj0 = 0 ;
15006 char * kwnames[] = {
15007 (char *) "stream", NULL
15008 };
15009
15010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15011 {
15012 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15013 arg1 = temp1->m_wxis;
15014 created1 = false;
15015 } else {
15016 PyErr_Clear(); // clear the failure of the wxPyConvert above
15017 arg1 = wxPyCBInputStream_create(obj0, false);
15018 if (arg1 == NULL) {
15019 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15020 SWIG_fail;
15021 }
15022 created1 = true;
15023 }
15024 }
15025 {
15026 PyThreadState* __tstate = wxPyBeginAllowThreads();
15027 result = (bool)wxImage::CanRead(*arg1);
15028 wxPyEndAllowThreads(__tstate);
15029 if (PyErr_Occurred()) SWIG_fail;
15030 }
15031 {
15032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15033 }
15034 {
15035 if (created1) delete arg1;
15036 }
15037 return resultobj;
15038 fail:
15039 {
15040 if (created1) delete arg1;
15041 }
15042 return NULL;
15043 }
15044
15045
15046 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15047 PyObject *resultobj = 0;
15048 wxImage *arg1 = (wxImage *) 0 ;
15049 wxInputStream *arg2 = 0 ;
15050 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15051 int arg4 = (int) -1 ;
15052 bool result;
15053 void *argp1 = 0 ;
15054 int res1 = 0 ;
15055 wxPyInputStream *temp2 ;
15056 bool created2 ;
15057 long val3 ;
15058 int ecode3 = 0 ;
15059 int val4 ;
15060 int ecode4 = 0 ;
15061 PyObject * obj0 = 0 ;
15062 PyObject * obj1 = 0 ;
15063 PyObject * obj2 = 0 ;
15064 PyObject * obj3 = 0 ;
15065 char * kwnames[] = {
15066 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15067 };
15068
15069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15071 if (!SWIG_IsOK(res1)) {
15072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15073 }
15074 arg1 = reinterpret_cast< wxImage * >(argp1);
15075 {
15076 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15077 arg2 = temp2->m_wxis;
15078 created2 = false;
15079 } else {
15080 PyErr_Clear(); // clear the failure of the wxPyConvert above
15081 arg2 = wxPyCBInputStream_create(obj1, false);
15082 if (arg2 == NULL) {
15083 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15084 SWIG_fail;
15085 }
15086 created2 = true;
15087 }
15088 }
15089 if (obj2) {
15090 ecode3 = SWIG_AsVal_long(obj2, &val3);
15091 if (!SWIG_IsOK(ecode3)) {
15092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15093 }
15094 arg3 = static_cast< long >(val3);
15095 }
15096 if (obj3) {
15097 ecode4 = SWIG_AsVal_int(obj3, &val4);
15098 if (!SWIG_IsOK(ecode4)) {
15099 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15100 }
15101 arg4 = static_cast< int >(val4);
15102 }
15103 {
15104 PyThreadState* __tstate = wxPyBeginAllowThreads();
15105 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15106 wxPyEndAllowThreads(__tstate);
15107 if (PyErr_Occurred()) SWIG_fail;
15108 }
15109 {
15110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15111 }
15112 {
15113 if (created2) delete arg2;
15114 }
15115 return resultobj;
15116 fail:
15117 {
15118 if (created2) delete arg2;
15119 }
15120 return NULL;
15121 }
15122
15123
15124 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15125 PyObject *resultobj = 0;
15126 wxImage *arg1 = (wxImage *) 0 ;
15127 wxInputStream *arg2 = 0 ;
15128 wxString *arg3 = 0 ;
15129 int arg4 = (int) -1 ;
15130 bool result;
15131 void *argp1 = 0 ;
15132 int res1 = 0 ;
15133 wxPyInputStream *temp2 ;
15134 bool created2 ;
15135 bool temp3 = false ;
15136 int val4 ;
15137 int ecode4 = 0 ;
15138 PyObject * obj0 = 0 ;
15139 PyObject * obj1 = 0 ;
15140 PyObject * obj2 = 0 ;
15141 PyObject * obj3 = 0 ;
15142 char * kwnames[] = {
15143 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15144 };
15145
15146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15148 if (!SWIG_IsOK(res1)) {
15149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15150 }
15151 arg1 = reinterpret_cast< wxImage * >(argp1);
15152 {
15153 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15154 arg2 = temp2->m_wxis;
15155 created2 = false;
15156 } else {
15157 PyErr_Clear(); // clear the failure of the wxPyConvert above
15158 arg2 = wxPyCBInputStream_create(obj1, false);
15159 if (arg2 == NULL) {
15160 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15161 SWIG_fail;
15162 }
15163 created2 = true;
15164 }
15165 }
15166 {
15167 arg3 = wxString_in_helper(obj2);
15168 if (arg3 == NULL) SWIG_fail;
15169 temp3 = true;
15170 }
15171 if (obj3) {
15172 ecode4 = SWIG_AsVal_int(obj3, &val4);
15173 if (!SWIG_IsOK(ecode4)) {
15174 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15175 }
15176 arg4 = static_cast< int >(val4);
15177 }
15178 {
15179 PyThreadState* __tstate = wxPyBeginAllowThreads();
15180 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15181 wxPyEndAllowThreads(__tstate);
15182 if (PyErr_Occurred()) SWIG_fail;
15183 }
15184 {
15185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15186 }
15187 {
15188 if (created2) delete arg2;
15189 }
15190 {
15191 if (temp3)
15192 delete arg3;
15193 }
15194 return resultobj;
15195 fail:
15196 {
15197 if (created2) delete arg2;
15198 }
15199 {
15200 if (temp3)
15201 delete arg3;
15202 }
15203 return NULL;
15204 }
15205
15206
15207 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15208 PyObject *resultobj = 0;
15209 wxImage *arg1 = (wxImage *) 0 ;
15210 bool result;
15211 void *argp1 = 0 ;
15212 int res1 = 0 ;
15213 PyObject *swig_obj[1] ;
15214
15215 if (!args) SWIG_fail;
15216 swig_obj[0] = args;
15217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15218 if (!SWIG_IsOK(res1)) {
15219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15220 }
15221 arg1 = reinterpret_cast< wxImage * >(argp1);
15222 {
15223 PyThreadState* __tstate = wxPyBeginAllowThreads();
15224 result = (bool)(arg1)->Ok();
15225 wxPyEndAllowThreads(__tstate);
15226 if (PyErr_Occurred()) SWIG_fail;
15227 }
15228 {
15229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15230 }
15231 return resultobj;
15232 fail:
15233 return NULL;
15234 }
15235
15236
15237 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15238 PyObject *resultobj = 0;
15239 wxImage *arg1 = (wxImage *) 0 ;
15240 int result;
15241 void *argp1 = 0 ;
15242 int res1 = 0 ;
15243 PyObject *swig_obj[1] ;
15244
15245 if (!args) SWIG_fail;
15246 swig_obj[0] = args;
15247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15248 if (!SWIG_IsOK(res1)) {
15249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15250 }
15251 arg1 = reinterpret_cast< wxImage * >(argp1);
15252 {
15253 PyThreadState* __tstate = wxPyBeginAllowThreads();
15254 result = (int)(arg1)->GetWidth();
15255 wxPyEndAllowThreads(__tstate);
15256 if (PyErr_Occurred()) SWIG_fail;
15257 }
15258 resultobj = SWIG_From_int(static_cast< int >(result));
15259 return resultobj;
15260 fail:
15261 return NULL;
15262 }
15263
15264
15265 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15266 PyObject *resultobj = 0;
15267 wxImage *arg1 = (wxImage *) 0 ;
15268 int result;
15269 void *argp1 = 0 ;
15270 int res1 = 0 ;
15271 PyObject *swig_obj[1] ;
15272
15273 if (!args) SWIG_fail;
15274 swig_obj[0] = args;
15275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15276 if (!SWIG_IsOK(res1)) {
15277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15278 }
15279 arg1 = reinterpret_cast< wxImage * >(argp1);
15280 {
15281 PyThreadState* __tstate = wxPyBeginAllowThreads();
15282 result = (int)(arg1)->GetHeight();
15283 wxPyEndAllowThreads(__tstate);
15284 if (PyErr_Occurred()) SWIG_fail;
15285 }
15286 resultobj = SWIG_From_int(static_cast< int >(result));
15287 return resultobj;
15288 fail:
15289 return NULL;
15290 }
15291
15292
15293 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15294 PyObject *resultobj = 0;
15295 wxImage *arg1 = (wxImage *) 0 ;
15296 wxSize result;
15297 void *argp1 = 0 ;
15298 int res1 = 0 ;
15299 PyObject *swig_obj[1] ;
15300
15301 if (!args) SWIG_fail;
15302 swig_obj[0] = args;
15303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15304 if (!SWIG_IsOK(res1)) {
15305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15306 }
15307 arg1 = reinterpret_cast< wxImage * >(argp1);
15308 {
15309 PyThreadState* __tstate = wxPyBeginAllowThreads();
15310 result = wxImage_GetSize(arg1);
15311 wxPyEndAllowThreads(__tstate);
15312 if (PyErr_Occurred()) SWIG_fail;
15313 }
15314 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15315 return resultobj;
15316 fail:
15317 return NULL;
15318 }
15319
15320
15321 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15322 PyObject *resultobj = 0;
15323 wxImage *arg1 = (wxImage *) 0 ;
15324 wxRect *arg2 = 0 ;
15325 SwigValueWrapper<wxImage > result;
15326 void *argp1 = 0 ;
15327 int res1 = 0 ;
15328 wxRect temp2 ;
15329 PyObject * obj0 = 0 ;
15330 PyObject * obj1 = 0 ;
15331 char * kwnames[] = {
15332 (char *) "self",(char *) "rect", NULL
15333 };
15334
15335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15337 if (!SWIG_IsOK(res1)) {
15338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15339 }
15340 arg1 = reinterpret_cast< wxImage * >(argp1);
15341 {
15342 arg2 = &temp2;
15343 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15344 }
15345 {
15346 PyThreadState* __tstate = wxPyBeginAllowThreads();
15347 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15348 wxPyEndAllowThreads(__tstate);
15349 if (PyErr_Occurred()) SWIG_fail;
15350 }
15351 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15352 return resultobj;
15353 fail:
15354 return NULL;
15355 }
15356
15357
15358 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15359 PyObject *resultobj = 0;
15360 wxImage *arg1 = (wxImage *) 0 ;
15361 wxSize *arg2 = 0 ;
15362 wxPoint *arg3 = 0 ;
15363 int arg4 = (int) -1 ;
15364 int arg5 = (int) -1 ;
15365 int arg6 = (int) -1 ;
15366 SwigValueWrapper<wxImage > result;
15367 void *argp1 = 0 ;
15368 int res1 = 0 ;
15369 wxSize temp2 ;
15370 wxPoint temp3 ;
15371 int val4 ;
15372 int ecode4 = 0 ;
15373 int val5 ;
15374 int ecode5 = 0 ;
15375 int val6 ;
15376 int ecode6 = 0 ;
15377 PyObject * obj0 = 0 ;
15378 PyObject * obj1 = 0 ;
15379 PyObject * obj2 = 0 ;
15380 PyObject * obj3 = 0 ;
15381 PyObject * obj4 = 0 ;
15382 PyObject * obj5 = 0 ;
15383 char * kwnames[] = {
15384 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15385 };
15386
15387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15389 if (!SWIG_IsOK(res1)) {
15390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15391 }
15392 arg1 = reinterpret_cast< wxImage * >(argp1);
15393 {
15394 arg2 = &temp2;
15395 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15396 }
15397 {
15398 arg3 = &temp3;
15399 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15400 }
15401 if (obj3) {
15402 ecode4 = SWIG_AsVal_int(obj3, &val4);
15403 if (!SWIG_IsOK(ecode4)) {
15404 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15405 }
15406 arg4 = static_cast< int >(val4);
15407 }
15408 if (obj4) {
15409 ecode5 = SWIG_AsVal_int(obj4, &val5);
15410 if (!SWIG_IsOK(ecode5)) {
15411 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15412 }
15413 arg5 = static_cast< int >(val5);
15414 }
15415 if (obj5) {
15416 ecode6 = SWIG_AsVal_int(obj5, &val6);
15417 if (!SWIG_IsOK(ecode6)) {
15418 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15419 }
15420 arg6 = static_cast< int >(val6);
15421 }
15422 {
15423 PyThreadState* __tstate = wxPyBeginAllowThreads();
15424 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15425 wxPyEndAllowThreads(__tstate);
15426 if (PyErr_Occurred()) SWIG_fail;
15427 }
15428 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15429 return resultobj;
15430 fail:
15431 return NULL;
15432 }
15433
15434
15435 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15436 PyObject *resultobj = 0;
15437 wxImage *arg1 = (wxImage *) 0 ;
15438 SwigValueWrapper<wxImage > result;
15439 void *argp1 = 0 ;
15440 int res1 = 0 ;
15441 PyObject *swig_obj[1] ;
15442
15443 if (!args) SWIG_fail;
15444 swig_obj[0] = args;
15445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15446 if (!SWIG_IsOK(res1)) {
15447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15448 }
15449 arg1 = reinterpret_cast< wxImage * >(argp1);
15450 {
15451 PyThreadState* __tstate = wxPyBeginAllowThreads();
15452 result = (arg1)->Copy();
15453 wxPyEndAllowThreads(__tstate);
15454 if (PyErr_Occurred()) SWIG_fail;
15455 }
15456 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15457 return resultobj;
15458 fail:
15459 return NULL;
15460 }
15461
15462
15463 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15464 PyObject *resultobj = 0;
15465 wxImage *arg1 = (wxImage *) 0 ;
15466 wxImage *arg2 = 0 ;
15467 int arg3 ;
15468 int arg4 ;
15469 void *argp1 = 0 ;
15470 int res1 = 0 ;
15471 void *argp2 = 0 ;
15472 int res2 = 0 ;
15473 int val3 ;
15474 int ecode3 = 0 ;
15475 int val4 ;
15476 int ecode4 = 0 ;
15477 PyObject * obj0 = 0 ;
15478 PyObject * obj1 = 0 ;
15479 PyObject * obj2 = 0 ;
15480 PyObject * obj3 = 0 ;
15481 char * kwnames[] = {
15482 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15483 };
15484
15485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15487 if (!SWIG_IsOK(res1)) {
15488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15489 }
15490 arg1 = reinterpret_cast< wxImage * >(argp1);
15491 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15492 if (!SWIG_IsOK(res2)) {
15493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15494 }
15495 if (!argp2) {
15496 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15497 }
15498 arg2 = reinterpret_cast< wxImage * >(argp2);
15499 ecode3 = SWIG_AsVal_int(obj2, &val3);
15500 if (!SWIG_IsOK(ecode3)) {
15501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15502 }
15503 arg3 = static_cast< int >(val3);
15504 ecode4 = SWIG_AsVal_int(obj3, &val4);
15505 if (!SWIG_IsOK(ecode4)) {
15506 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15507 }
15508 arg4 = static_cast< int >(val4);
15509 {
15510 PyThreadState* __tstate = wxPyBeginAllowThreads();
15511 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15512 wxPyEndAllowThreads(__tstate);
15513 if (PyErr_Occurred()) SWIG_fail;
15514 }
15515 resultobj = SWIG_Py_Void();
15516 return resultobj;
15517 fail:
15518 return NULL;
15519 }
15520
15521
15522 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15523 PyObject *resultobj = 0;
15524 wxImage *arg1 = (wxImage *) 0 ;
15525 PyObject *result = 0 ;
15526 void *argp1 = 0 ;
15527 int res1 = 0 ;
15528 PyObject *swig_obj[1] ;
15529
15530 if (!args) SWIG_fail;
15531 swig_obj[0] = args;
15532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15533 if (!SWIG_IsOK(res1)) {
15534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15535 }
15536 arg1 = reinterpret_cast< wxImage * >(argp1);
15537 {
15538 PyThreadState* __tstate = wxPyBeginAllowThreads();
15539 result = (PyObject *)wxImage_GetData(arg1);
15540 wxPyEndAllowThreads(__tstate);
15541 if (PyErr_Occurred()) SWIG_fail;
15542 }
15543 resultobj = result;
15544 return resultobj;
15545 fail:
15546 return NULL;
15547 }
15548
15549
15550 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15551 PyObject *resultobj = 0;
15552 wxImage *arg1 = (wxImage *) 0 ;
15553 buffer arg2 ;
15554 int arg3 ;
15555 void *argp1 = 0 ;
15556 int res1 = 0 ;
15557 Py_ssize_t temp2 ;
15558 PyObject * obj0 = 0 ;
15559 PyObject * obj1 = 0 ;
15560 char * kwnames[] = {
15561 (char *) "self",(char *) "data", NULL
15562 };
15563
15564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15566 if (!SWIG_IsOK(res1)) {
15567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15568 }
15569 arg1 = reinterpret_cast< wxImage * >(argp1);
15570 {
15571 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15572 arg3 = (int)temp2;
15573 }
15574 {
15575 PyThreadState* __tstate = wxPyBeginAllowThreads();
15576 wxImage_SetData(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_GetDataBuffer(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_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15600 }
15601 arg1 = reinterpret_cast< wxImage * >(argp1);
15602 {
15603 PyThreadState* __tstate = wxPyBeginAllowThreads();
15604 result = (PyObject *)wxImage_GetDataBuffer(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_SetDataBuffer(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 Py_ssize_t temp2 ;
15623 PyObject * obj0 = 0 ;
15624 PyObject * obj1 = 0 ;
15625 char * kwnames[] = {
15626 (char *) "self",(char *) "data", NULL
15627 };
15628
15629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15631 if (!SWIG_IsOK(res1)) {
15632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15633 }
15634 arg1 = reinterpret_cast< wxImage * >(argp1);
15635 {
15636 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15637 arg3 = (int)temp2;
15638 }
15639 {
15640 PyThreadState* __tstate = wxPyBeginAllowThreads();
15641 wxImage_SetDataBuffer(arg1,arg2,arg3);
15642 wxPyEndAllowThreads(__tstate);
15643 if (PyErr_Occurred()) SWIG_fail;
15644 }
15645 resultobj = SWIG_Py_Void();
15646 return resultobj;
15647 fail:
15648 return NULL;
15649 }
15650
15651
15652 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15653 PyObject *resultobj = 0;
15654 wxImage *arg1 = (wxImage *) 0 ;
15655 PyObject *result = 0 ;
15656 void *argp1 = 0 ;
15657 int res1 = 0 ;
15658 PyObject *swig_obj[1] ;
15659
15660 if (!args) SWIG_fail;
15661 swig_obj[0] = args;
15662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15663 if (!SWIG_IsOK(res1)) {
15664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15665 }
15666 arg1 = reinterpret_cast< wxImage * >(argp1);
15667 {
15668 PyThreadState* __tstate = wxPyBeginAllowThreads();
15669 result = (PyObject *)wxImage_GetAlphaData(arg1);
15670 wxPyEndAllowThreads(__tstate);
15671 if (PyErr_Occurred()) SWIG_fail;
15672 }
15673 resultobj = result;
15674 return resultobj;
15675 fail:
15676 return NULL;
15677 }
15678
15679
15680 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15681 PyObject *resultobj = 0;
15682 wxImage *arg1 = (wxImage *) 0 ;
15683 buffer arg2 ;
15684 int arg3 ;
15685 void *argp1 = 0 ;
15686 int res1 = 0 ;
15687 Py_ssize_t temp2 ;
15688 PyObject * obj0 = 0 ;
15689 PyObject * obj1 = 0 ;
15690 char * kwnames[] = {
15691 (char *) "self",(char *) "alpha", NULL
15692 };
15693
15694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15696 if (!SWIG_IsOK(res1)) {
15697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15698 }
15699 arg1 = reinterpret_cast< wxImage * >(argp1);
15700 {
15701 if (obj1 != Py_None) {
15702 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15703 arg3 = (int)temp2;
15704 }
15705 }
15706 {
15707 PyThreadState* __tstate = wxPyBeginAllowThreads();
15708 wxImage_SetAlphaData(arg1,arg2,arg3);
15709 wxPyEndAllowThreads(__tstate);
15710 if (PyErr_Occurred()) SWIG_fail;
15711 }
15712 resultobj = SWIG_Py_Void();
15713 return resultobj;
15714 fail:
15715 return NULL;
15716 }
15717
15718
15719 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15720 PyObject *resultobj = 0;
15721 wxImage *arg1 = (wxImage *) 0 ;
15722 PyObject *result = 0 ;
15723 void *argp1 = 0 ;
15724 int res1 = 0 ;
15725 PyObject *swig_obj[1] ;
15726
15727 if (!args) SWIG_fail;
15728 swig_obj[0] = args;
15729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15730 if (!SWIG_IsOK(res1)) {
15731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15732 }
15733 arg1 = reinterpret_cast< wxImage * >(argp1);
15734 {
15735 PyThreadState* __tstate = wxPyBeginAllowThreads();
15736 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15737 wxPyEndAllowThreads(__tstate);
15738 if (PyErr_Occurred()) SWIG_fail;
15739 }
15740 resultobj = result;
15741 return resultobj;
15742 fail:
15743 return NULL;
15744 }
15745
15746
15747 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15748 PyObject *resultobj = 0;
15749 wxImage *arg1 = (wxImage *) 0 ;
15750 buffer arg2 ;
15751 int arg3 ;
15752 void *argp1 = 0 ;
15753 int res1 = 0 ;
15754 Py_ssize_t temp2 ;
15755 PyObject * obj0 = 0 ;
15756 PyObject * obj1 = 0 ;
15757 char * kwnames[] = {
15758 (char *) "self",(char *) "alpha", NULL
15759 };
15760
15761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15763 if (!SWIG_IsOK(res1)) {
15764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15765 }
15766 arg1 = reinterpret_cast< wxImage * >(argp1);
15767 {
15768 if (obj1 != Py_None) {
15769 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15770 arg3 = (int)temp2;
15771 }
15772 }
15773 {
15774 PyThreadState* __tstate = wxPyBeginAllowThreads();
15775 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15776 wxPyEndAllowThreads(__tstate);
15777 if (PyErr_Occurred()) SWIG_fail;
15778 }
15779 resultobj = SWIG_Py_Void();
15780 return resultobj;
15781 fail:
15782 return NULL;
15783 }
15784
15785
15786 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15787 PyObject *resultobj = 0;
15788 wxImage *arg1 = (wxImage *) 0 ;
15789 byte arg2 ;
15790 byte arg3 ;
15791 byte arg4 ;
15792 void *argp1 = 0 ;
15793 int res1 = 0 ;
15794 unsigned char val2 ;
15795 int ecode2 = 0 ;
15796 unsigned char val3 ;
15797 int ecode3 = 0 ;
15798 unsigned char val4 ;
15799 int ecode4 = 0 ;
15800 PyObject * obj0 = 0 ;
15801 PyObject * obj1 = 0 ;
15802 PyObject * obj2 = 0 ;
15803 PyObject * obj3 = 0 ;
15804 char * kwnames[] = {
15805 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15806 };
15807
15808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15810 if (!SWIG_IsOK(res1)) {
15811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15812 }
15813 arg1 = reinterpret_cast< wxImage * >(argp1);
15814 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15815 if (!SWIG_IsOK(ecode2)) {
15816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15817 }
15818 arg2 = static_cast< byte >(val2);
15819 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15820 if (!SWIG_IsOK(ecode3)) {
15821 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15822 }
15823 arg3 = static_cast< byte >(val3);
15824 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15825 if (!SWIG_IsOK(ecode4)) {
15826 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15827 }
15828 arg4 = static_cast< byte >(val4);
15829 {
15830 PyThreadState* __tstate = wxPyBeginAllowThreads();
15831 (arg1)->SetMaskColour(arg2,arg3,arg4);
15832 wxPyEndAllowThreads(__tstate);
15833 if (PyErr_Occurred()) SWIG_fail;
15834 }
15835 resultobj = SWIG_Py_Void();
15836 return resultobj;
15837 fail:
15838 return NULL;
15839 }
15840
15841
15842 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15843 PyObject *resultobj = 0;
15844 wxImage *arg1 = (wxImage *) 0 ;
15845 byte *arg2 = (byte *) 0 ;
15846 byte *arg3 = (byte *) 0 ;
15847 byte *arg4 = (byte *) 0 ;
15848 void *argp1 = 0 ;
15849 int res1 = 0 ;
15850 byte temp2 ;
15851 int res2 = SWIG_TMPOBJ ;
15852 byte temp3 ;
15853 int res3 = SWIG_TMPOBJ ;
15854 byte temp4 ;
15855 int res4 = SWIG_TMPOBJ ;
15856 PyObject *swig_obj[1] ;
15857
15858 arg2 = &temp2;
15859 arg3 = &temp3;
15860 arg4 = &temp4;
15861 if (!args) SWIG_fail;
15862 swig_obj[0] = args;
15863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15864 if (!SWIG_IsOK(res1)) {
15865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15866 }
15867 arg1 = reinterpret_cast< wxImage * >(argp1);
15868 {
15869 PyThreadState* __tstate = wxPyBeginAllowThreads();
15870 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15871 wxPyEndAllowThreads(__tstate);
15872 if (PyErr_Occurred()) SWIG_fail;
15873 }
15874 resultobj = SWIG_Py_Void();
15875 if (SWIG_IsTmpObj(res2)) {
15876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15877 } else {
15878 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15879 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15880 }
15881 if (SWIG_IsTmpObj(res3)) {
15882 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15883 } else {
15884 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15885 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15886 }
15887 if (SWIG_IsTmpObj(res4)) {
15888 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15889 } else {
15890 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15891 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15892 }
15893 return resultobj;
15894 fail:
15895 return NULL;
15896 }
15897
15898
15899 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15900 PyObject *resultobj = 0;
15901 wxImage *arg1 = (wxImage *) 0 ;
15902 byte result;
15903 void *argp1 = 0 ;
15904 int res1 = 0 ;
15905 PyObject *swig_obj[1] ;
15906
15907 if (!args) SWIG_fail;
15908 swig_obj[0] = args;
15909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15910 if (!SWIG_IsOK(res1)) {
15911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15912 }
15913 arg1 = reinterpret_cast< wxImage * >(argp1);
15914 {
15915 PyThreadState* __tstate = wxPyBeginAllowThreads();
15916 result = (byte)(arg1)->GetMaskRed();
15917 wxPyEndAllowThreads(__tstate);
15918 if (PyErr_Occurred()) SWIG_fail;
15919 }
15920 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15921 return resultobj;
15922 fail:
15923 return NULL;
15924 }
15925
15926
15927 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15928 PyObject *resultobj = 0;
15929 wxImage *arg1 = (wxImage *) 0 ;
15930 byte result;
15931 void *argp1 = 0 ;
15932 int res1 = 0 ;
15933 PyObject *swig_obj[1] ;
15934
15935 if (!args) SWIG_fail;
15936 swig_obj[0] = args;
15937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15938 if (!SWIG_IsOK(res1)) {
15939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15940 }
15941 arg1 = reinterpret_cast< wxImage * >(argp1);
15942 {
15943 PyThreadState* __tstate = wxPyBeginAllowThreads();
15944 result = (byte)(arg1)->GetMaskGreen();
15945 wxPyEndAllowThreads(__tstate);
15946 if (PyErr_Occurred()) SWIG_fail;
15947 }
15948 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15949 return resultobj;
15950 fail:
15951 return NULL;
15952 }
15953
15954
15955 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15956 PyObject *resultobj = 0;
15957 wxImage *arg1 = (wxImage *) 0 ;
15958 byte result;
15959 void *argp1 = 0 ;
15960 int res1 = 0 ;
15961 PyObject *swig_obj[1] ;
15962
15963 if (!args) SWIG_fail;
15964 swig_obj[0] = args;
15965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15966 if (!SWIG_IsOK(res1)) {
15967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15968 }
15969 arg1 = reinterpret_cast< wxImage * >(argp1);
15970 {
15971 PyThreadState* __tstate = wxPyBeginAllowThreads();
15972 result = (byte)(arg1)->GetMaskBlue();
15973 wxPyEndAllowThreads(__tstate);
15974 if (PyErr_Occurred()) SWIG_fail;
15975 }
15976 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15977 return resultobj;
15978 fail:
15979 return NULL;
15980 }
15981
15982
15983 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15984 PyObject *resultobj = 0;
15985 wxImage *arg1 = (wxImage *) 0 ;
15986 bool arg2 = (bool) true ;
15987 void *argp1 = 0 ;
15988 int res1 = 0 ;
15989 bool val2 ;
15990 int ecode2 = 0 ;
15991 PyObject * obj0 = 0 ;
15992 PyObject * obj1 = 0 ;
15993 char * kwnames[] = {
15994 (char *) "self",(char *) "mask", NULL
15995 };
15996
15997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15999 if (!SWIG_IsOK(res1)) {
16000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16001 }
16002 arg1 = reinterpret_cast< wxImage * >(argp1);
16003 if (obj1) {
16004 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16005 if (!SWIG_IsOK(ecode2)) {
16006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16007 }
16008 arg2 = static_cast< bool >(val2);
16009 }
16010 {
16011 PyThreadState* __tstate = wxPyBeginAllowThreads();
16012 (arg1)->SetMask(arg2);
16013 wxPyEndAllowThreads(__tstate);
16014 if (PyErr_Occurred()) SWIG_fail;
16015 }
16016 resultobj = SWIG_Py_Void();
16017 return resultobj;
16018 fail:
16019 return NULL;
16020 }
16021
16022
16023 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16024 PyObject *resultobj = 0;
16025 wxImage *arg1 = (wxImage *) 0 ;
16026 bool result;
16027 void *argp1 = 0 ;
16028 int res1 = 0 ;
16029 PyObject *swig_obj[1] ;
16030
16031 if (!args) SWIG_fail;
16032 swig_obj[0] = args;
16033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16034 if (!SWIG_IsOK(res1)) {
16035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16036 }
16037 arg1 = reinterpret_cast< wxImage * >(argp1);
16038 {
16039 PyThreadState* __tstate = wxPyBeginAllowThreads();
16040 result = (bool)(arg1)->HasMask();
16041 wxPyEndAllowThreads(__tstate);
16042 if (PyErr_Occurred()) SWIG_fail;
16043 }
16044 {
16045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16046 }
16047 return resultobj;
16048 fail:
16049 return NULL;
16050 }
16051
16052
16053 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16054 PyObject *resultobj = 0;
16055 wxImage *arg1 = (wxImage *) 0 ;
16056 double arg2 ;
16057 wxPoint *arg3 = 0 ;
16058 bool arg4 = (bool) true ;
16059 wxPoint *arg5 = (wxPoint *) NULL ;
16060 SwigValueWrapper<wxImage > result;
16061 void *argp1 = 0 ;
16062 int res1 = 0 ;
16063 double val2 ;
16064 int ecode2 = 0 ;
16065 wxPoint temp3 ;
16066 bool val4 ;
16067 int ecode4 = 0 ;
16068 void *argp5 = 0 ;
16069 int res5 = 0 ;
16070 PyObject * obj0 = 0 ;
16071 PyObject * obj1 = 0 ;
16072 PyObject * obj2 = 0 ;
16073 PyObject * obj3 = 0 ;
16074 PyObject * obj4 = 0 ;
16075 char * kwnames[] = {
16076 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16077 };
16078
16079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16081 if (!SWIG_IsOK(res1)) {
16082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16083 }
16084 arg1 = reinterpret_cast< wxImage * >(argp1);
16085 ecode2 = SWIG_AsVal_double(obj1, &val2);
16086 if (!SWIG_IsOK(ecode2)) {
16087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16088 }
16089 arg2 = static_cast< double >(val2);
16090 {
16091 arg3 = &temp3;
16092 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16093 }
16094 if (obj3) {
16095 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16096 if (!SWIG_IsOK(ecode4)) {
16097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16098 }
16099 arg4 = static_cast< bool >(val4);
16100 }
16101 if (obj4) {
16102 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16103 if (!SWIG_IsOK(res5)) {
16104 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16105 }
16106 arg5 = reinterpret_cast< wxPoint * >(argp5);
16107 }
16108 {
16109 PyThreadState* __tstate = wxPyBeginAllowThreads();
16110 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16111 wxPyEndAllowThreads(__tstate);
16112 if (PyErr_Occurred()) SWIG_fail;
16113 }
16114 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16115 return resultobj;
16116 fail:
16117 return NULL;
16118 }
16119
16120
16121 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16122 PyObject *resultobj = 0;
16123 wxImage *arg1 = (wxImage *) 0 ;
16124 bool arg2 = (bool) true ;
16125 SwigValueWrapper<wxImage > result;
16126 void *argp1 = 0 ;
16127 int res1 = 0 ;
16128 bool val2 ;
16129 int ecode2 = 0 ;
16130 PyObject * obj0 = 0 ;
16131 PyObject * obj1 = 0 ;
16132 char * kwnames[] = {
16133 (char *) "self",(char *) "clockwise", NULL
16134 };
16135
16136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16138 if (!SWIG_IsOK(res1)) {
16139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16140 }
16141 arg1 = reinterpret_cast< wxImage * >(argp1);
16142 if (obj1) {
16143 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16144 if (!SWIG_IsOK(ecode2)) {
16145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16146 }
16147 arg2 = static_cast< bool >(val2);
16148 }
16149 {
16150 PyThreadState* __tstate = wxPyBeginAllowThreads();
16151 result = (arg1)->Rotate90(arg2);
16152 wxPyEndAllowThreads(__tstate);
16153 if (PyErr_Occurred()) SWIG_fail;
16154 }
16155 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16156 return resultobj;
16157 fail:
16158 return NULL;
16159 }
16160
16161
16162 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16163 PyObject *resultobj = 0;
16164 wxImage *arg1 = (wxImage *) 0 ;
16165 bool arg2 = (bool) true ;
16166 SwigValueWrapper<wxImage > result;
16167 void *argp1 = 0 ;
16168 int res1 = 0 ;
16169 bool val2 ;
16170 int ecode2 = 0 ;
16171 PyObject * obj0 = 0 ;
16172 PyObject * obj1 = 0 ;
16173 char * kwnames[] = {
16174 (char *) "self",(char *) "horizontally", NULL
16175 };
16176
16177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16179 if (!SWIG_IsOK(res1)) {
16180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16181 }
16182 arg1 = reinterpret_cast< wxImage * >(argp1);
16183 if (obj1) {
16184 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16185 if (!SWIG_IsOK(ecode2)) {
16186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16187 }
16188 arg2 = static_cast< bool >(val2);
16189 }
16190 {
16191 PyThreadState* __tstate = wxPyBeginAllowThreads();
16192 result = (arg1)->Mirror(arg2);
16193 wxPyEndAllowThreads(__tstate);
16194 if (PyErr_Occurred()) SWIG_fail;
16195 }
16196 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16197 return resultobj;
16198 fail:
16199 return NULL;
16200 }
16201
16202
16203 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16204 PyObject *resultobj = 0;
16205 wxImage *arg1 = (wxImage *) 0 ;
16206 byte arg2 ;
16207 byte arg3 ;
16208 byte arg4 ;
16209 byte arg5 ;
16210 byte arg6 ;
16211 byte arg7 ;
16212 void *argp1 = 0 ;
16213 int res1 = 0 ;
16214 unsigned char val2 ;
16215 int ecode2 = 0 ;
16216 unsigned char val3 ;
16217 int ecode3 = 0 ;
16218 unsigned char val4 ;
16219 int ecode4 = 0 ;
16220 unsigned char val5 ;
16221 int ecode5 = 0 ;
16222 unsigned char val6 ;
16223 int ecode6 = 0 ;
16224 unsigned char val7 ;
16225 int ecode7 = 0 ;
16226 PyObject * obj0 = 0 ;
16227 PyObject * obj1 = 0 ;
16228 PyObject * obj2 = 0 ;
16229 PyObject * obj3 = 0 ;
16230 PyObject * obj4 = 0 ;
16231 PyObject * obj5 = 0 ;
16232 PyObject * obj6 = 0 ;
16233 char * kwnames[] = {
16234 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16235 };
16236
16237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16239 if (!SWIG_IsOK(res1)) {
16240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16241 }
16242 arg1 = reinterpret_cast< wxImage * >(argp1);
16243 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16244 if (!SWIG_IsOK(ecode2)) {
16245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16246 }
16247 arg2 = static_cast< byte >(val2);
16248 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16249 if (!SWIG_IsOK(ecode3)) {
16250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16251 }
16252 arg3 = static_cast< byte >(val3);
16253 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16254 if (!SWIG_IsOK(ecode4)) {
16255 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16256 }
16257 arg4 = static_cast< byte >(val4);
16258 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16259 if (!SWIG_IsOK(ecode5)) {
16260 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16261 }
16262 arg5 = static_cast< byte >(val5);
16263 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16264 if (!SWIG_IsOK(ecode6)) {
16265 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16266 }
16267 arg6 = static_cast< byte >(val6);
16268 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16269 if (!SWIG_IsOK(ecode7)) {
16270 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16271 }
16272 arg7 = static_cast< byte >(val7);
16273 {
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16276 wxPyEndAllowThreads(__tstate);
16277 if (PyErr_Occurred()) SWIG_fail;
16278 }
16279 resultobj = SWIG_Py_Void();
16280 return resultobj;
16281 fail:
16282 return NULL;
16283 }
16284
16285
16286 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16287 PyObject *resultobj = 0;
16288 wxImage *arg1 = (wxImage *) 0 ;
16289 double arg2 = (double) 0.299 ;
16290 double arg3 = (double) 0.587 ;
16291 double arg4 = (double) 0.114 ;
16292 SwigValueWrapper<wxImage > result;
16293 void *argp1 = 0 ;
16294 int res1 = 0 ;
16295 double val2 ;
16296 int ecode2 = 0 ;
16297 double val3 ;
16298 int ecode3 = 0 ;
16299 double val4 ;
16300 int ecode4 = 0 ;
16301 PyObject * obj0 = 0 ;
16302 PyObject * obj1 = 0 ;
16303 PyObject * obj2 = 0 ;
16304 PyObject * obj3 = 0 ;
16305 char * kwnames[] = {
16306 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16307 };
16308
16309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16311 if (!SWIG_IsOK(res1)) {
16312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16313 }
16314 arg1 = reinterpret_cast< wxImage * >(argp1);
16315 if (obj1) {
16316 ecode2 = SWIG_AsVal_double(obj1, &val2);
16317 if (!SWIG_IsOK(ecode2)) {
16318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16319 }
16320 arg2 = static_cast< double >(val2);
16321 }
16322 if (obj2) {
16323 ecode3 = SWIG_AsVal_double(obj2, &val3);
16324 if (!SWIG_IsOK(ecode3)) {
16325 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16326 }
16327 arg3 = static_cast< double >(val3);
16328 }
16329 if (obj3) {
16330 ecode4 = SWIG_AsVal_double(obj3, &val4);
16331 if (!SWIG_IsOK(ecode4)) {
16332 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16333 }
16334 arg4 = static_cast< double >(val4);
16335 }
16336 {
16337 PyThreadState* __tstate = wxPyBeginAllowThreads();
16338 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16339 wxPyEndAllowThreads(__tstate);
16340 if (PyErr_Occurred()) SWIG_fail;
16341 }
16342 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16343 return resultobj;
16344 fail:
16345 return NULL;
16346 }
16347
16348
16349 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16350 PyObject *resultobj = 0;
16351 wxImage *arg1 = (wxImage *) 0 ;
16352 byte arg2 ;
16353 byte arg3 ;
16354 byte arg4 ;
16355 SwigValueWrapper<wxImage > result;
16356 void *argp1 = 0 ;
16357 int res1 = 0 ;
16358 unsigned char val2 ;
16359 int ecode2 = 0 ;
16360 unsigned char val3 ;
16361 int ecode3 = 0 ;
16362 unsigned char val4 ;
16363 int ecode4 = 0 ;
16364 PyObject * obj0 = 0 ;
16365 PyObject * obj1 = 0 ;
16366 PyObject * obj2 = 0 ;
16367 PyObject * obj3 = 0 ;
16368 char * kwnames[] = {
16369 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16370 };
16371
16372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16374 if (!SWIG_IsOK(res1)) {
16375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16376 }
16377 arg1 = reinterpret_cast< wxImage * >(argp1);
16378 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16379 if (!SWIG_IsOK(ecode2)) {
16380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16381 }
16382 arg2 = static_cast< byte >(val2);
16383 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16384 if (!SWIG_IsOK(ecode3)) {
16385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16386 }
16387 arg3 = static_cast< byte >(val3);
16388 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16389 if (!SWIG_IsOK(ecode4)) {
16390 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16391 }
16392 arg4 = static_cast< byte >(val4);
16393 {
16394 PyThreadState* __tstate = wxPyBeginAllowThreads();
16395 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16396 wxPyEndAllowThreads(__tstate);
16397 if (PyErr_Occurred()) SWIG_fail;
16398 }
16399 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16400 return resultobj;
16401 fail:
16402 return NULL;
16403 }
16404
16405
16406 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16407 PyObject *resultobj = 0;
16408 wxImage *arg1 = (wxImage *) 0 ;
16409 wxString *arg2 = 0 ;
16410 wxString *arg3 = 0 ;
16411 void *argp1 = 0 ;
16412 int res1 = 0 ;
16413 bool temp2 = false ;
16414 bool temp3 = false ;
16415 PyObject * obj0 = 0 ;
16416 PyObject * obj1 = 0 ;
16417 PyObject * obj2 = 0 ;
16418 char * kwnames[] = {
16419 (char *) "self",(char *) "name",(char *) "value", NULL
16420 };
16421
16422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16424 if (!SWIG_IsOK(res1)) {
16425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16426 }
16427 arg1 = reinterpret_cast< wxImage * >(argp1);
16428 {
16429 arg2 = wxString_in_helper(obj1);
16430 if (arg2 == NULL) SWIG_fail;
16431 temp2 = true;
16432 }
16433 {
16434 arg3 = wxString_in_helper(obj2);
16435 if (arg3 == NULL) SWIG_fail;
16436 temp3 = true;
16437 }
16438 {
16439 PyThreadState* __tstate = wxPyBeginAllowThreads();
16440 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16441 wxPyEndAllowThreads(__tstate);
16442 if (PyErr_Occurred()) SWIG_fail;
16443 }
16444 resultobj = SWIG_Py_Void();
16445 {
16446 if (temp2)
16447 delete arg2;
16448 }
16449 {
16450 if (temp3)
16451 delete arg3;
16452 }
16453 return resultobj;
16454 fail:
16455 {
16456 if (temp2)
16457 delete arg2;
16458 }
16459 {
16460 if (temp3)
16461 delete arg3;
16462 }
16463 return NULL;
16464 }
16465
16466
16467 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16468 PyObject *resultobj = 0;
16469 wxImage *arg1 = (wxImage *) 0 ;
16470 wxString *arg2 = 0 ;
16471 int arg3 ;
16472 void *argp1 = 0 ;
16473 int res1 = 0 ;
16474 bool temp2 = false ;
16475 int val3 ;
16476 int ecode3 = 0 ;
16477 PyObject * obj0 = 0 ;
16478 PyObject * obj1 = 0 ;
16479 PyObject * obj2 = 0 ;
16480 char * kwnames[] = {
16481 (char *) "self",(char *) "name",(char *) "value", NULL
16482 };
16483
16484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16486 if (!SWIG_IsOK(res1)) {
16487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16488 }
16489 arg1 = reinterpret_cast< wxImage * >(argp1);
16490 {
16491 arg2 = wxString_in_helper(obj1);
16492 if (arg2 == NULL) SWIG_fail;
16493 temp2 = true;
16494 }
16495 ecode3 = SWIG_AsVal_int(obj2, &val3);
16496 if (!SWIG_IsOK(ecode3)) {
16497 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16498 }
16499 arg3 = static_cast< int >(val3);
16500 {
16501 PyThreadState* __tstate = wxPyBeginAllowThreads();
16502 (arg1)->SetOption((wxString const &)*arg2,arg3);
16503 wxPyEndAllowThreads(__tstate);
16504 if (PyErr_Occurred()) SWIG_fail;
16505 }
16506 resultobj = SWIG_Py_Void();
16507 {
16508 if (temp2)
16509 delete arg2;
16510 }
16511 return resultobj;
16512 fail:
16513 {
16514 if (temp2)
16515 delete arg2;
16516 }
16517 return NULL;
16518 }
16519
16520
16521 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16522 PyObject *resultobj = 0;
16523 wxImage *arg1 = (wxImage *) 0 ;
16524 wxString *arg2 = 0 ;
16525 wxString result;
16526 void *argp1 = 0 ;
16527 int res1 = 0 ;
16528 bool temp2 = false ;
16529 PyObject * obj0 = 0 ;
16530 PyObject * obj1 = 0 ;
16531 char * kwnames[] = {
16532 (char *) "self",(char *) "name", NULL
16533 };
16534
16535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16537 if (!SWIG_IsOK(res1)) {
16538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16539 }
16540 arg1 = reinterpret_cast< wxImage * >(argp1);
16541 {
16542 arg2 = wxString_in_helper(obj1);
16543 if (arg2 == NULL) SWIG_fail;
16544 temp2 = true;
16545 }
16546 {
16547 PyThreadState* __tstate = wxPyBeginAllowThreads();
16548 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16549 wxPyEndAllowThreads(__tstate);
16550 if (PyErr_Occurred()) SWIG_fail;
16551 }
16552 {
16553 #if wxUSE_UNICODE
16554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16555 #else
16556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16557 #endif
16558 }
16559 {
16560 if (temp2)
16561 delete arg2;
16562 }
16563 return resultobj;
16564 fail:
16565 {
16566 if (temp2)
16567 delete arg2;
16568 }
16569 return NULL;
16570 }
16571
16572
16573 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16574 PyObject *resultobj = 0;
16575 wxImage *arg1 = (wxImage *) 0 ;
16576 wxString *arg2 = 0 ;
16577 int result;
16578 void *argp1 = 0 ;
16579 int res1 = 0 ;
16580 bool temp2 = false ;
16581 PyObject * obj0 = 0 ;
16582 PyObject * obj1 = 0 ;
16583 char * kwnames[] = {
16584 (char *) "self",(char *) "name", NULL
16585 };
16586
16587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",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_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16591 }
16592 arg1 = reinterpret_cast< wxImage * >(argp1);
16593 {
16594 arg2 = wxString_in_helper(obj1);
16595 if (arg2 == NULL) SWIG_fail;
16596 temp2 = true;
16597 }
16598 {
16599 PyThreadState* __tstate = wxPyBeginAllowThreads();
16600 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16601 wxPyEndAllowThreads(__tstate);
16602 if (PyErr_Occurred()) SWIG_fail;
16603 }
16604 resultobj = SWIG_From_int(static_cast< int >(result));
16605 {
16606 if (temp2)
16607 delete arg2;
16608 }
16609 return resultobj;
16610 fail:
16611 {
16612 if (temp2)
16613 delete arg2;
16614 }
16615 return NULL;
16616 }
16617
16618
16619 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16620 PyObject *resultobj = 0;
16621 wxImage *arg1 = (wxImage *) 0 ;
16622 wxString *arg2 = 0 ;
16623 bool result;
16624 void *argp1 = 0 ;
16625 int res1 = 0 ;
16626 bool temp2 = false ;
16627 PyObject * obj0 = 0 ;
16628 PyObject * obj1 = 0 ;
16629 char * kwnames[] = {
16630 (char *) "self",(char *) "name", NULL
16631 };
16632
16633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16635 if (!SWIG_IsOK(res1)) {
16636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16637 }
16638 arg1 = reinterpret_cast< wxImage * >(argp1);
16639 {
16640 arg2 = wxString_in_helper(obj1);
16641 if (arg2 == NULL) SWIG_fail;
16642 temp2 = true;
16643 }
16644 {
16645 PyThreadState* __tstate = wxPyBeginAllowThreads();
16646 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16647 wxPyEndAllowThreads(__tstate);
16648 if (PyErr_Occurred()) SWIG_fail;
16649 }
16650 {
16651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16652 }
16653 {
16654 if (temp2)
16655 delete arg2;
16656 }
16657 return resultobj;
16658 fail:
16659 {
16660 if (temp2)
16661 delete arg2;
16662 }
16663 return NULL;
16664 }
16665
16666
16667 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16668 PyObject *resultobj = 0;
16669 wxImage *arg1 = (wxImage *) 0 ;
16670 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16671 unsigned long result;
16672 void *argp1 = 0 ;
16673 int res1 = 0 ;
16674 unsigned long val2 ;
16675 int ecode2 = 0 ;
16676 PyObject * obj0 = 0 ;
16677 PyObject * obj1 = 0 ;
16678 char * kwnames[] = {
16679 (char *) "self",(char *) "stopafter", NULL
16680 };
16681
16682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16684 if (!SWIG_IsOK(res1)) {
16685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16686 }
16687 arg1 = reinterpret_cast< wxImage * >(argp1);
16688 if (obj1) {
16689 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16690 if (!SWIG_IsOK(ecode2)) {
16691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16692 }
16693 arg2 = static_cast< unsigned long >(val2);
16694 }
16695 {
16696 PyThreadState* __tstate = wxPyBeginAllowThreads();
16697 result = (unsigned long)(arg1)->CountColours(arg2);
16698 wxPyEndAllowThreads(__tstate);
16699 if (PyErr_Occurred()) SWIG_fail;
16700 }
16701 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16702 return resultobj;
16703 fail:
16704 return NULL;
16705 }
16706
16707
16708 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16709 PyObject *resultobj = 0;
16710 wxImage *arg1 = (wxImage *) 0 ;
16711 wxImageHistogram *arg2 = 0 ;
16712 unsigned long result;
16713 void *argp1 = 0 ;
16714 int res1 = 0 ;
16715 void *argp2 = 0 ;
16716 int res2 = 0 ;
16717 PyObject * obj0 = 0 ;
16718 PyObject * obj1 = 0 ;
16719 char * kwnames[] = {
16720 (char *) "self",(char *) "h", NULL
16721 };
16722
16723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16725 if (!SWIG_IsOK(res1)) {
16726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16727 }
16728 arg1 = reinterpret_cast< wxImage * >(argp1);
16729 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16730 if (!SWIG_IsOK(res2)) {
16731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16732 }
16733 if (!argp2) {
16734 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16735 }
16736 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16737 {
16738 PyThreadState* __tstate = wxPyBeginAllowThreads();
16739 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16740 wxPyEndAllowThreads(__tstate);
16741 if (PyErr_Occurred()) SWIG_fail;
16742 }
16743 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16744 return resultobj;
16745 fail:
16746 return NULL;
16747 }
16748
16749
16750 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16751 PyObject *resultobj = 0;
16752 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16753 void *argp1 = 0 ;
16754 int res1 = 0 ;
16755 PyObject * obj0 = 0 ;
16756 char * kwnames[] = {
16757 (char *) "handler", NULL
16758 };
16759
16760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16762 if (!SWIG_IsOK(res1)) {
16763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16764 }
16765 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16766 {
16767 PyThreadState* __tstate = wxPyBeginAllowThreads();
16768 wxImage::AddHandler(arg1);
16769 wxPyEndAllowThreads(__tstate);
16770 if (PyErr_Occurred()) SWIG_fail;
16771 }
16772 resultobj = SWIG_Py_Void();
16773 return resultobj;
16774 fail:
16775 return NULL;
16776 }
16777
16778
16779 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16780 PyObject *resultobj = 0;
16781 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16782 void *argp1 = 0 ;
16783 int res1 = 0 ;
16784 PyObject * obj0 = 0 ;
16785 char * kwnames[] = {
16786 (char *) "handler", NULL
16787 };
16788
16789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16791 if (!SWIG_IsOK(res1)) {
16792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16793 }
16794 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16795 {
16796 PyThreadState* __tstate = wxPyBeginAllowThreads();
16797 wxImage::InsertHandler(arg1);
16798 wxPyEndAllowThreads(__tstate);
16799 if (PyErr_Occurred()) SWIG_fail;
16800 }
16801 resultobj = SWIG_Py_Void();
16802 return resultobj;
16803 fail:
16804 return NULL;
16805 }
16806
16807
16808 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16809 PyObject *resultobj = 0;
16810 wxString *arg1 = 0 ;
16811 bool result;
16812 bool temp1 = false ;
16813 PyObject * obj0 = 0 ;
16814 char * kwnames[] = {
16815 (char *) "name", NULL
16816 };
16817
16818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16819 {
16820 arg1 = wxString_in_helper(obj0);
16821 if (arg1 == NULL) SWIG_fail;
16822 temp1 = true;
16823 }
16824 {
16825 PyThreadState* __tstate = wxPyBeginAllowThreads();
16826 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16827 wxPyEndAllowThreads(__tstate);
16828 if (PyErr_Occurred()) SWIG_fail;
16829 }
16830 {
16831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16832 }
16833 {
16834 if (temp1)
16835 delete arg1;
16836 }
16837 return resultobj;
16838 fail:
16839 {
16840 if (temp1)
16841 delete arg1;
16842 }
16843 return NULL;
16844 }
16845
16846
16847 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16848 PyObject *resultobj = 0;
16849 PyObject *result = 0 ;
16850
16851 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16852 {
16853 PyThreadState* __tstate = wxPyBeginAllowThreads();
16854 result = (PyObject *)wxImage_GetHandlers();
16855 wxPyEndAllowThreads(__tstate);
16856 if (PyErr_Occurred()) SWIG_fail;
16857 }
16858 resultobj = result;
16859 return resultobj;
16860 fail:
16861 return NULL;
16862 }
16863
16864
16865 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16866 PyObject *resultobj = 0;
16867 wxString result;
16868
16869 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16870 {
16871 PyThreadState* __tstate = wxPyBeginAllowThreads();
16872 result = wxImage::GetImageExtWildcard();
16873 wxPyEndAllowThreads(__tstate);
16874 if (PyErr_Occurred()) SWIG_fail;
16875 }
16876 {
16877 #if wxUSE_UNICODE
16878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16879 #else
16880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16881 #endif
16882 }
16883 return resultobj;
16884 fail:
16885 return NULL;
16886 }
16887
16888
16889 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16890 PyObject *resultobj = 0;
16891 wxImage *arg1 = (wxImage *) 0 ;
16892 int arg2 = (int) -1 ;
16893 wxBitmap result;
16894 void *argp1 = 0 ;
16895 int res1 = 0 ;
16896 int val2 ;
16897 int ecode2 = 0 ;
16898 PyObject * obj0 = 0 ;
16899 PyObject * obj1 = 0 ;
16900 char * kwnames[] = {
16901 (char *) "self",(char *) "depth", NULL
16902 };
16903
16904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16906 if (!SWIG_IsOK(res1)) {
16907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16908 }
16909 arg1 = reinterpret_cast< wxImage * >(argp1);
16910 if (obj1) {
16911 ecode2 = SWIG_AsVal_int(obj1, &val2);
16912 if (!SWIG_IsOK(ecode2)) {
16913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16914 }
16915 arg2 = static_cast< int >(val2);
16916 }
16917 {
16918 if (!wxPyCheckForApp()) SWIG_fail;
16919 PyThreadState* __tstate = wxPyBeginAllowThreads();
16920 result = wxImage_ConvertToBitmap(arg1,arg2);
16921 wxPyEndAllowThreads(__tstate);
16922 if (PyErr_Occurred()) SWIG_fail;
16923 }
16924 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16925 return resultobj;
16926 fail:
16927 return NULL;
16928 }
16929
16930
16931 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16932 PyObject *resultobj = 0;
16933 wxImage *arg1 = (wxImage *) 0 ;
16934 byte arg2 ;
16935 byte arg3 ;
16936 byte arg4 ;
16937 wxBitmap result;
16938 void *argp1 = 0 ;
16939 int res1 = 0 ;
16940 unsigned char val2 ;
16941 int ecode2 = 0 ;
16942 unsigned char val3 ;
16943 int ecode3 = 0 ;
16944 unsigned char val4 ;
16945 int ecode4 = 0 ;
16946 PyObject * obj0 = 0 ;
16947 PyObject * obj1 = 0 ;
16948 PyObject * obj2 = 0 ;
16949 PyObject * obj3 = 0 ;
16950 char * kwnames[] = {
16951 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16952 };
16953
16954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16956 if (!SWIG_IsOK(res1)) {
16957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16958 }
16959 arg1 = reinterpret_cast< wxImage * >(argp1);
16960 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16961 if (!SWIG_IsOK(ecode2)) {
16962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16963 }
16964 arg2 = static_cast< byte >(val2);
16965 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16966 if (!SWIG_IsOK(ecode3)) {
16967 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16968 }
16969 arg3 = static_cast< byte >(val3);
16970 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16971 if (!SWIG_IsOK(ecode4)) {
16972 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16973 }
16974 arg4 = static_cast< byte >(val4);
16975 {
16976 if (!wxPyCheckForApp()) SWIG_fail;
16977 PyThreadState* __tstate = wxPyBeginAllowThreads();
16978 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16979 wxPyEndAllowThreads(__tstate);
16980 if (PyErr_Occurred()) SWIG_fail;
16981 }
16982 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16983 return resultobj;
16984 fail:
16985 return NULL;
16986 }
16987
16988
16989 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16990 PyObject *resultobj = 0;
16991 wxImage *arg1 = (wxImage *) 0 ;
16992 double arg2 ;
16993 void *argp1 = 0 ;
16994 int res1 = 0 ;
16995 double val2 ;
16996 int ecode2 = 0 ;
16997 PyObject * obj0 = 0 ;
16998 PyObject * obj1 = 0 ;
16999 char * kwnames[] = {
17000 (char *) "self",(char *) "angle", NULL
17001 };
17002
17003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17005 if (!SWIG_IsOK(res1)) {
17006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17007 }
17008 arg1 = reinterpret_cast< wxImage * >(argp1);
17009 ecode2 = SWIG_AsVal_double(obj1, &val2);
17010 if (!SWIG_IsOK(ecode2)) {
17011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17012 }
17013 arg2 = static_cast< double >(val2);
17014 {
17015 PyThreadState* __tstate = wxPyBeginAllowThreads();
17016 (arg1)->RotateHue(arg2);
17017 wxPyEndAllowThreads(__tstate);
17018 if (PyErr_Occurred()) SWIG_fail;
17019 }
17020 resultobj = SWIG_Py_Void();
17021 return resultobj;
17022 fail:
17023 return NULL;
17024 }
17025
17026
17027 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17028 PyObject *resultobj = 0;
17029 wxImage_RGBValue arg1 ;
17030 wxImage_HSVValue result;
17031 void *argp1 ;
17032 int res1 = 0 ;
17033 PyObject * obj0 = 0 ;
17034 char * kwnames[] = {
17035 (char *) "rgb", NULL
17036 };
17037
17038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17039 {
17040 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17041 if (!SWIG_IsOK(res1)) {
17042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17043 }
17044 if (!argp1) {
17045 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17046 } else {
17047 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17048 arg1 = *temp;
17049 if (SWIG_IsNewObj(res1)) delete temp;
17050 }
17051 }
17052 {
17053 PyThreadState* __tstate = wxPyBeginAllowThreads();
17054 result = wxImage::RGBtoHSV(arg1);
17055 wxPyEndAllowThreads(__tstate);
17056 if (PyErr_Occurred()) SWIG_fail;
17057 }
17058 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17059 return resultobj;
17060 fail:
17061 return NULL;
17062 }
17063
17064
17065 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17066 PyObject *resultobj = 0;
17067 wxImage_HSVValue arg1 ;
17068 wxImage_RGBValue result;
17069 void *argp1 ;
17070 int res1 = 0 ;
17071 PyObject * obj0 = 0 ;
17072 char * kwnames[] = {
17073 (char *) "hsv", NULL
17074 };
17075
17076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17077 {
17078 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17079 if (!SWIG_IsOK(res1)) {
17080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17081 }
17082 if (!argp1) {
17083 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17084 } else {
17085 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17086 arg1 = *temp;
17087 if (SWIG_IsNewObj(res1)) delete temp;
17088 }
17089 }
17090 {
17091 PyThreadState* __tstate = wxPyBeginAllowThreads();
17092 result = wxImage::HSVtoRGB(arg1);
17093 wxPyEndAllowThreads(__tstate);
17094 if (PyErr_Occurred()) SWIG_fail;
17095 }
17096 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17097 return resultobj;
17098 fail:
17099 return NULL;
17100 }
17101
17102
17103 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17104 PyObject *obj;
17105 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17106 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17107 return SWIG_Py_Void();
17108 }
17109
17110 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17111 return SWIG_Python_InitShadowInstance(args);
17112 }
17113
17114 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17115 PyObject *resultobj = 0;
17116 int arg1 ;
17117 int arg2 ;
17118 buffer arg3 ;
17119 int arg4 ;
17120 buffer arg5 = (buffer) NULL ;
17121 int arg6 = (int) 0 ;
17122 wxImage *result = 0 ;
17123 int val1 ;
17124 int ecode1 = 0 ;
17125 int val2 ;
17126 int ecode2 = 0 ;
17127 Py_ssize_t temp3 ;
17128 Py_ssize_t temp5 ;
17129 PyObject * obj0 = 0 ;
17130 PyObject * obj1 = 0 ;
17131 PyObject * obj2 = 0 ;
17132 PyObject * obj3 = 0 ;
17133 char * kwnames[] = {
17134 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17135 };
17136
17137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17138 ecode1 = SWIG_AsVal_int(obj0, &val1);
17139 if (!SWIG_IsOK(ecode1)) {
17140 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17141 }
17142 arg1 = static_cast< int >(val1);
17143 ecode2 = SWIG_AsVal_int(obj1, &val2);
17144 if (!SWIG_IsOK(ecode2)) {
17145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17146 }
17147 arg2 = static_cast< int >(val2);
17148 {
17149 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17150 arg4 = (int)temp3;
17151 }
17152 if (obj3) {
17153 {
17154 if (obj3 != Py_None) {
17155 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17156 arg6 = (int)temp5;
17157 }
17158 }
17159 }
17160 {
17161 PyThreadState* __tstate = wxPyBeginAllowThreads();
17162 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17163 wxPyEndAllowThreads(__tstate);
17164 if (PyErr_Occurred()) SWIG_fail;
17165 }
17166 {
17167 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17168 }
17169 return resultobj;
17170 fail:
17171 return NULL;
17172 }
17173
17174
17175 SWIGINTERN int NullImage_set(PyObject *) {
17176 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17177 return 1;
17178 }
17179
17180
17181 SWIGINTERN PyObject *NullImage_get(void) {
17182 PyObject *pyobj = 0;
17183
17184 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17185 return pyobj;
17186 }
17187
17188
17189 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17190 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17191 return 1;
17192 }
17193
17194
17195 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17196 PyObject *pyobj = 0;
17197
17198 {
17199 #if wxUSE_UNICODE
17200 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17201 #else
17202 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17203 #endif
17204 }
17205 return pyobj;
17206 }
17207
17208
17209 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17210 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17211 return 1;
17212 }
17213
17214
17215 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17216 PyObject *pyobj = 0;
17217
17218 {
17219 #if wxUSE_UNICODE
17220 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17221 #else
17222 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17223 #endif
17224 }
17225 return pyobj;
17226 }
17227
17228
17229 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17230 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17231 return 1;
17232 }
17233
17234
17235 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17236 PyObject *pyobj = 0;
17237
17238 {
17239 #if wxUSE_UNICODE
17240 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17241 #else
17242 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17243 #endif
17244 }
17245 return pyobj;
17246 }
17247
17248
17249 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17250 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17251 return 1;
17252 }
17253
17254
17255 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17256 PyObject *pyobj = 0;
17257
17258 {
17259 #if wxUSE_UNICODE
17260 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17261 #else
17262 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17263 #endif
17264 }
17265 return pyobj;
17266 }
17267
17268
17269 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17270 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17271 return 1;
17272 }
17273
17274
17275 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17276 PyObject *pyobj = 0;
17277
17278 {
17279 #if wxUSE_UNICODE
17280 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17281 #else
17282 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17283 #endif
17284 }
17285 return pyobj;
17286 }
17287
17288
17289 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17290 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17291 return 1;
17292 }
17293
17294
17295 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17296 PyObject *pyobj = 0;
17297
17298 {
17299 #if wxUSE_UNICODE
17300 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17301 #else
17302 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17303 #endif
17304 }
17305 return pyobj;
17306 }
17307
17308
17309 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17310 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17311 return 1;
17312 }
17313
17314
17315 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17316 PyObject *pyobj = 0;
17317
17318 {
17319 #if wxUSE_UNICODE
17320 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17321 #else
17322 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17323 #endif
17324 }
17325 return pyobj;
17326 }
17327
17328
17329 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17330 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17331 return 1;
17332 }
17333
17334
17335 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17336 PyObject *pyobj = 0;
17337
17338 {
17339 #if wxUSE_UNICODE
17340 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17341 #else
17342 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17343 #endif
17344 }
17345 return pyobj;
17346 }
17347
17348
17349 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17350 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17351 return 1;
17352 }
17353
17354
17355 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17356 PyObject *pyobj = 0;
17357
17358 {
17359 #if wxUSE_UNICODE
17360 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17361 #else
17362 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17363 #endif
17364 }
17365 return pyobj;
17366 }
17367
17368
17369 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17370 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17371 return 1;
17372 }
17373
17374
17375 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17376 PyObject *pyobj = 0;
17377
17378 {
17379 #if wxUSE_UNICODE
17380 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17381 #else
17382 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17383 #endif
17384 }
17385 return pyobj;
17386 }
17387
17388
17389 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17390 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17391 return 1;
17392 }
17393
17394
17395 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17396 PyObject *pyobj = 0;
17397
17398 {
17399 #if wxUSE_UNICODE
17400 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17401 #else
17402 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17403 #endif
17404 }
17405 return pyobj;
17406 }
17407
17408
17409 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17410 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17411 return 1;
17412 }
17413
17414
17415 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17416 PyObject *pyobj = 0;
17417
17418 {
17419 #if wxUSE_UNICODE
17420 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17421 #else
17422 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17423 #endif
17424 }
17425 return pyobj;
17426 }
17427
17428
17429 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17430 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17431 return 1;
17432 }
17433
17434
17435 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17436 PyObject *pyobj = 0;
17437
17438 {
17439 #if wxUSE_UNICODE
17440 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17441 #else
17442 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17443 #endif
17444 }
17445 return pyobj;
17446 }
17447
17448
17449 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17450 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17451 return 1;
17452 }
17453
17454
17455 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17456 PyObject *pyobj = 0;
17457
17458 {
17459 #if wxUSE_UNICODE
17460 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17461 #else
17462 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17463 #endif
17464 }
17465 return pyobj;
17466 }
17467
17468
17469 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17470 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17471 return 1;
17472 }
17473
17474
17475 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17476 PyObject *pyobj = 0;
17477
17478 {
17479 #if wxUSE_UNICODE
17480 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17481 #else
17482 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17483 #endif
17484 }
17485 return pyobj;
17486 }
17487
17488
17489 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17490 PyObject *resultobj = 0;
17491 wxBMPHandler *result = 0 ;
17492
17493 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17494 {
17495 PyThreadState* __tstate = wxPyBeginAllowThreads();
17496 result = (wxBMPHandler *)new wxBMPHandler();
17497 wxPyEndAllowThreads(__tstate);
17498 if (PyErr_Occurred()) SWIG_fail;
17499 }
17500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17501 return resultobj;
17502 fail:
17503 return NULL;
17504 }
17505
17506
17507 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17508 PyObject *obj;
17509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17510 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17511 return SWIG_Py_Void();
17512 }
17513
17514 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17515 return SWIG_Python_InitShadowInstance(args);
17516 }
17517
17518 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17519 PyObject *resultobj = 0;
17520 wxICOHandler *result = 0 ;
17521
17522 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17523 {
17524 PyThreadState* __tstate = wxPyBeginAllowThreads();
17525 result = (wxICOHandler *)new wxICOHandler();
17526 wxPyEndAllowThreads(__tstate);
17527 if (PyErr_Occurred()) SWIG_fail;
17528 }
17529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17530 return resultobj;
17531 fail:
17532 return NULL;
17533 }
17534
17535
17536 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17537 PyObject *obj;
17538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17539 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17540 return SWIG_Py_Void();
17541 }
17542
17543 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17544 return SWIG_Python_InitShadowInstance(args);
17545 }
17546
17547 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17548 PyObject *resultobj = 0;
17549 wxCURHandler *result = 0 ;
17550
17551 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17552 {
17553 PyThreadState* __tstate = wxPyBeginAllowThreads();
17554 result = (wxCURHandler *)new wxCURHandler();
17555 wxPyEndAllowThreads(__tstate);
17556 if (PyErr_Occurred()) SWIG_fail;
17557 }
17558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17559 return resultobj;
17560 fail:
17561 return NULL;
17562 }
17563
17564
17565 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17566 PyObject *obj;
17567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17568 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17569 return SWIG_Py_Void();
17570 }
17571
17572 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17573 return SWIG_Python_InitShadowInstance(args);
17574 }
17575
17576 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17577 PyObject *resultobj = 0;
17578 wxANIHandler *result = 0 ;
17579
17580 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17581 {
17582 PyThreadState* __tstate = wxPyBeginAllowThreads();
17583 result = (wxANIHandler *)new wxANIHandler();
17584 wxPyEndAllowThreads(__tstate);
17585 if (PyErr_Occurred()) SWIG_fail;
17586 }
17587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17588 return resultobj;
17589 fail:
17590 return NULL;
17591 }
17592
17593
17594 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17595 PyObject *obj;
17596 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17597 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17598 return SWIG_Py_Void();
17599 }
17600
17601 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17602 return SWIG_Python_InitShadowInstance(args);
17603 }
17604
17605 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17606 PyObject *resultobj = 0;
17607 wxPNGHandler *result = 0 ;
17608
17609 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17610 {
17611 PyThreadState* __tstate = wxPyBeginAllowThreads();
17612 result = (wxPNGHandler *)new wxPNGHandler();
17613 wxPyEndAllowThreads(__tstate);
17614 if (PyErr_Occurred()) SWIG_fail;
17615 }
17616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17617 return resultobj;
17618 fail:
17619 return NULL;
17620 }
17621
17622
17623 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17624 PyObject *obj;
17625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17626 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17627 return SWIG_Py_Void();
17628 }
17629
17630 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17631 return SWIG_Python_InitShadowInstance(args);
17632 }
17633
17634 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17635 PyObject *resultobj = 0;
17636 wxGIFHandler *result = 0 ;
17637
17638 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17639 {
17640 PyThreadState* __tstate = wxPyBeginAllowThreads();
17641 result = (wxGIFHandler *)new wxGIFHandler();
17642 wxPyEndAllowThreads(__tstate);
17643 if (PyErr_Occurred()) SWIG_fail;
17644 }
17645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17646 return resultobj;
17647 fail:
17648 return NULL;
17649 }
17650
17651
17652 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17653 PyObject *obj;
17654 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17655 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17656 return SWIG_Py_Void();
17657 }
17658
17659 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17660 return SWIG_Python_InitShadowInstance(args);
17661 }
17662
17663 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17664 PyObject *resultobj = 0;
17665 wxPCXHandler *result = 0 ;
17666
17667 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17668 {
17669 PyThreadState* __tstate = wxPyBeginAllowThreads();
17670 result = (wxPCXHandler *)new wxPCXHandler();
17671 wxPyEndAllowThreads(__tstate);
17672 if (PyErr_Occurred()) SWIG_fail;
17673 }
17674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17675 return resultobj;
17676 fail:
17677 return NULL;
17678 }
17679
17680
17681 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17682 PyObject *obj;
17683 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17684 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17685 return SWIG_Py_Void();
17686 }
17687
17688 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17689 return SWIG_Python_InitShadowInstance(args);
17690 }
17691
17692 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17693 PyObject *resultobj = 0;
17694 wxJPEGHandler *result = 0 ;
17695
17696 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17697 {
17698 PyThreadState* __tstate = wxPyBeginAllowThreads();
17699 result = (wxJPEGHandler *)new wxJPEGHandler();
17700 wxPyEndAllowThreads(__tstate);
17701 if (PyErr_Occurred()) SWIG_fail;
17702 }
17703 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17704 return resultobj;
17705 fail:
17706 return NULL;
17707 }
17708
17709
17710 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17711 PyObject *obj;
17712 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17713 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17714 return SWIG_Py_Void();
17715 }
17716
17717 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17718 return SWIG_Python_InitShadowInstance(args);
17719 }
17720
17721 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17722 PyObject *resultobj = 0;
17723 wxPNMHandler *result = 0 ;
17724
17725 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17726 {
17727 PyThreadState* __tstate = wxPyBeginAllowThreads();
17728 result = (wxPNMHandler *)new wxPNMHandler();
17729 wxPyEndAllowThreads(__tstate);
17730 if (PyErr_Occurred()) SWIG_fail;
17731 }
17732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17733 return resultobj;
17734 fail:
17735 return NULL;
17736 }
17737
17738
17739 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17740 PyObject *obj;
17741 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17742 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17743 return SWIG_Py_Void();
17744 }
17745
17746 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17747 return SWIG_Python_InitShadowInstance(args);
17748 }
17749
17750 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17751 PyObject *resultobj = 0;
17752 wxXPMHandler *result = 0 ;
17753
17754 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17755 {
17756 PyThreadState* __tstate = wxPyBeginAllowThreads();
17757 result = (wxXPMHandler *)new wxXPMHandler();
17758 wxPyEndAllowThreads(__tstate);
17759 if (PyErr_Occurred()) SWIG_fail;
17760 }
17761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17762 return resultobj;
17763 fail:
17764 return NULL;
17765 }
17766
17767
17768 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17769 PyObject *obj;
17770 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17771 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17772 return SWIG_Py_Void();
17773 }
17774
17775 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17776 return SWIG_Python_InitShadowInstance(args);
17777 }
17778
17779 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17780 PyObject *resultobj = 0;
17781 wxTIFFHandler *result = 0 ;
17782
17783 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17784 {
17785 PyThreadState* __tstate = wxPyBeginAllowThreads();
17786 result = (wxTIFFHandler *)new wxTIFFHandler();
17787 wxPyEndAllowThreads(__tstate);
17788 if (PyErr_Occurred()) SWIG_fail;
17789 }
17790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17791 return resultobj;
17792 fail:
17793 return NULL;
17794 }
17795
17796
17797 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17798 PyObject *obj;
17799 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17800 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17801 return SWIG_Py_Void();
17802 }
17803
17804 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17805 return SWIG_Python_InitShadowInstance(args);
17806 }
17807
17808 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17809 PyObject *resultobj = 0;
17810 wxImage *arg1 = 0 ;
17811 wxImage *arg2 = 0 ;
17812 int arg3 = (int) 236 ;
17813 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17814 bool result;
17815 void *argp1 = 0 ;
17816 int res1 = 0 ;
17817 void *argp2 = 0 ;
17818 int res2 = 0 ;
17819 int val3 ;
17820 int ecode3 = 0 ;
17821 int val4 ;
17822 int ecode4 = 0 ;
17823 PyObject * obj0 = 0 ;
17824 PyObject * obj1 = 0 ;
17825 PyObject * obj2 = 0 ;
17826 PyObject * obj3 = 0 ;
17827 char * kwnames[] = {
17828 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17829 };
17830
17831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17832 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17833 if (!SWIG_IsOK(res1)) {
17834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17835 }
17836 if (!argp1) {
17837 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17838 }
17839 arg1 = reinterpret_cast< wxImage * >(argp1);
17840 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17841 if (!SWIG_IsOK(res2)) {
17842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17843 }
17844 if (!argp2) {
17845 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17846 }
17847 arg2 = reinterpret_cast< wxImage * >(argp2);
17848 if (obj2) {
17849 ecode3 = SWIG_AsVal_int(obj2, &val3);
17850 if (!SWIG_IsOK(ecode3)) {
17851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17852 }
17853 arg3 = static_cast< int >(val3);
17854 }
17855 if (obj3) {
17856 ecode4 = SWIG_AsVal_int(obj3, &val4);
17857 if (!SWIG_IsOK(ecode4)) {
17858 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17859 }
17860 arg4 = static_cast< int >(val4);
17861 }
17862 {
17863 PyThreadState* __tstate = wxPyBeginAllowThreads();
17864 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17865 wxPyEndAllowThreads(__tstate);
17866 if (PyErr_Occurred()) SWIG_fail;
17867 }
17868 {
17869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17870 }
17871 return resultobj;
17872 fail:
17873 return NULL;
17874 }
17875
17876
17877 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17878 PyObject *obj;
17879 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17880 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17881 return SWIG_Py_Void();
17882 }
17883
17884 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17885 PyObject *resultobj = 0;
17886 wxEvtHandler *result = 0 ;
17887
17888 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17889 {
17890 PyThreadState* __tstate = wxPyBeginAllowThreads();
17891 result = (wxEvtHandler *)new wxEvtHandler();
17892 wxPyEndAllowThreads(__tstate);
17893 if (PyErr_Occurred()) SWIG_fail;
17894 }
17895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17896 return resultobj;
17897 fail:
17898 return NULL;
17899 }
17900
17901
17902 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17903 PyObject *resultobj = 0;
17904 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17905 wxEvtHandler *result = 0 ;
17906 void *argp1 = 0 ;
17907 int res1 = 0 ;
17908 PyObject *swig_obj[1] ;
17909
17910 if (!args) SWIG_fail;
17911 swig_obj[0] = args;
17912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17913 if (!SWIG_IsOK(res1)) {
17914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17915 }
17916 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17917 {
17918 PyThreadState* __tstate = wxPyBeginAllowThreads();
17919 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17920 wxPyEndAllowThreads(__tstate);
17921 if (PyErr_Occurred()) SWIG_fail;
17922 }
17923 {
17924 resultobj = wxPyMake_wxObject(result, 0);
17925 }
17926 return resultobj;
17927 fail:
17928 return NULL;
17929 }
17930
17931
17932 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17933 PyObject *resultobj = 0;
17934 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17935 wxEvtHandler *result = 0 ;
17936 void *argp1 = 0 ;
17937 int res1 = 0 ;
17938 PyObject *swig_obj[1] ;
17939
17940 if (!args) SWIG_fail;
17941 swig_obj[0] = args;
17942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17943 if (!SWIG_IsOK(res1)) {
17944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17945 }
17946 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17947 {
17948 PyThreadState* __tstate = wxPyBeginAllowThreads();
17949 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17950 wxPyEndAllowThreads(__tstate);
17951 if (PyErr_Occurred()) SWIG_fail;
17952 }
17953 {
17954 resultobj = wxPyMake_wxObject(result, 0);
17955 }
17956 return resultobj;
17957 fail:
17958 return NULL;
17959 }
17960
17961
17962 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17963 PyObject *resultobj = 0;
17964 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17965 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17966 void *argp1 = 0 ;
17967 int res1 = 0 ;
17968 void *argp2 = 0 ;
17969 int res2 = 0 ;
17970 PyObject * obj0 = 0 ;
17971 PyObject * obj1 = 0 ;
17972 char * kwnames[] = {
17973 (char *) "self",(char *) "handler", NULL
17974 };
17975
17976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17978 if (!SWIG_IsOK(res1)) {
17979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17980 }
17981 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17982 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17983 if (!SWIG_IsOK(res2)) {
17984 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17985 }
17986 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17987 {
17988 PyThreadState* __tstate = wxPyBeginAllowThreads();
17989 (arg1)->SetNextHandler(arg2);
17990 wxPyEndAllowThreads(__tstate);
17991 if (PyErr_Occurred()) SWIG_fail;
17992 }
17993 resultobj = SWIG_Py_Void();
17994 return resultobj;
17995 fail:
17996 return NULL;
17997 }
17998
17999
18000 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18001 PyObject *resultobj = 0;
18002 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18003 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18004 void *argp1 = 0 ;
18005 int res1 = 0 ;
18006 void *argp2 = 0 ;
18007 int res2 = 0 ;
18008 PyObject * obj0 = 0 ;
18009 PyObject * obj1 = 0 ;
18010 char * kwnames[] = {
18011 (char *) "self",(char *) "handler", NULL
18012 };
18013
18014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18016 if (!SWIG_IsOK(res1)) {
18017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18018 }
18019 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18020 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18021 if (!SWIG_IsOK(res2)) {
18022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18023 }
18024 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18025 {
18026 PyThreadState* __tstate = wxPyBeginAllowThreads();
18027 (arg1)->SetPreviousHandler(arg2);
18028 wxPyEndAllowThreads(__tstate);
18029 if (PyErr_Occurred()) SWIG_fail;
18030 }
18031 resultobj = SWIG_Py_Void();
18032 return resultobj;
18033 fail:
18034 return NULL;
18035 }
18036
18037
18038 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18039 PyObject *resultobj = 0;
18040 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18041 bool result;
18042 void *argp1 = 0 ;
18043 int res1 = 0 ;
18044 PyObject *swig_obj[1] ;
18045
18046 if (!args) SWIG_fail;
18047 swig_obj[0] = args;
18048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18049 if (!SWIG_IsOK(res1)) {
18050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18051 }
18052 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18053 {
18054 PyThreadState* __tstate = wxPyBeginAllowThreads();
18055 result = (bool)(arg1)->GetEvtHandlerEnabled();
18056 wxPyEndAllowThreads(__tstate);
18057 if (PyErr_Occurred()) SWIG_fail;
18058 }
18059 {
18060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18061 }
18062 return resultobj;
18063 fail:
18064 return NULL;
18065 }
18066
18067
18068 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18069 PyObject *resultobj = 0;
18070 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18071 bool arg2 ;
18072 void *argp1 = 0 ;
18073 int res1 = 0 ;
18074 bool val2 ;
18075 int ecode2 = 0 ;
18076 PyObject * obj0 = 0 ;
18077 PyObject * obj1 = 0 ;
18078 char * kwnames[] = {
18079 (char *) "self",(char *) "enabled", NULL
18080 };
18081
18082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18084 if (!SWIG_IsOK(res1)) {
18085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18086 }
18087 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18088 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18089 if (!SWIG_IsOK(ecode2)) {
18090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18091 }
18092 arg2 = static_cast< bool >(val2);
18093 {
18094 PyThreadState* __tstate = wxPyBeginAllowThreads();
18095 (arg1)->SetEvtHandlerEnabled(arg2);
18096 wxPyEndAllowThreads(__tstate);
18097 if (PyErr_Occurred()) SWIG_fail;
18098 }
18099 resultobj = SWIG_Py_Void();
18100 return resultobj;
18101 fail:
18102 return NULL;
18103 }
18104
18105
18106 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18107 PyObject *resultobj = 0;
18108 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18109 wxEvent *arg2 = 0 ;
18110 bool result;
18111 void *argp1 = 0 ;
18112 int res1 = 0 ;
18113 void *argp2 = 0 ;
18114 int res2 = 0 ;
18115 PyObject * obj0 = 0 ;
18116 PyObject * obj1 = 0 ;
18117 char * kwnames[] = {
18118 (char *) "self",(char *) "event", NULL
18119 };
18120
18121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18123 if (!SWIG_IsOK(res1)) {
18124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18125 }
18126 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18127 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18128 if (!SWIG_IsOK(res2)) {
18129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18130 }
18131 if (!argp2) {
18132 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18133 }
18134 arg2 = reinterpret_cast< wxEvent * >(argp2);
18135 {
18136 PyThreadState* __tstate = wxPyBeginAllowThreads();
18137 result = (bool)(arg1)->ProcessEvent(*arg2);
18138 wxPyEndAllowThreads(__tstate);
18139 if (PyErr_Occurred()) SWIG_fail;
18140 }
18141 {
18142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18143 }
18144 return resultobj;
18145 fail:
18146 return NULL;
18147 }
18148
18149
18150 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18151 PyObject *resultobj = 0;
18152 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18153 wxEvent *arg2 = 0 ;
18154 void *argp1 = 0 ;
18155 int res1 = 0 ;
18156 void *argp2 = 0 ;
18157 int res2 = 0 ;
18158 PyObject * obj0 = 0 ;
18159 PyObject * obj1 = 0 ;
18160 char * kwnames[] = {
18161 (char *) "self",(char *) "event", NULL
18162 };
18163
18164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18166 if (!SWIG_IsOK(res1)) {
18167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18168 }
18169 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18170 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18171 if (!SWIG_IsOK(res2)) {
18172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18173 }
18174 if (!argp2) {
18175 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18176 }
18177 arg2 = reinterpret_cast< wxEvent * >(argp2);
18178 {
18179 PyThreadState* __tstate = wxPyBeginAllowThreads();
18180 (arg1)->AddPendingEvent(*arg2);
18181 wxPyEndAllowThreads(__tstate);
18182 if (PyErr_Occurred()) SWIG_fail;
18183 }
18184 resultobj = SWIG_Py_Void();
18185 return resultobj;
18186 fail:
18187 return NULL;
18188 }
18189
18190
18191 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18192 PyObject *resultobj = 0;
18193 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18194 void *argp1 = 0 ;
18195 int res1 = 0 ;
18196 PyObject *swig_obj[1] ;
18197
18198 if (!args) SWIG_fail;
18199 swig_obj[0] = args;
18200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18201 if (!SWIG_IsOK(res1)) {
18202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18203 }
18204 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18205 {
18206 PyThreadState* __tstate = wxPyBeginAllowThreads();
18207 (arg1)->ProcessPendingEvents();
18208 wxPyEndAllowThreads(__tstate);
18209 if (PyErr_Occurred()) SWIG_fail;
18210 }
18211 resultobj = SWIG_Py_Void();
18212 return resultobj;
18213 fail:
18214 return NULL;
18215 }
18216
18217
18218 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18219 PyObject *resultobj = 0;
18220 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18221 int arg2 ;
18222 int arg3 ;
18223 int arg4 ;
18224 PyObject *arg5 = (PyObject *) 0 ;
18225 void *argp1 = 0 ;
18226 int res1 = 0 ;
18227 int val2 ;
18228 int ecode2 = 0 ;
18229 int val3 ;
18230 int ecode3 = 0 ;
18231 int val4 ;
18232 int ecode4 = 0 ;
18233 PyObject * obj0 = 0 ;
18234 PyObject * obj1 = 0 ;
18235 PyObject * obj2 = 0 ;
18236 PyObject * obj3 = 0 ;
18237 PyObject * obj4 = 0 ;
18238 char * kwnames[] = {
18239 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18240 };
18241
18242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18244 if (!SWIG_IsOK(res1)) {
18245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18246 }
18247 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18248 ecode2 = SWIG_AsVal_int(obj1, &val2);
18249 if (!SWIG_IsOK(ecode2)) {
18250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18251 }
18252 arg2 = static_cast< int >(val2);
18253 ecode3 = SWIG_AsVal_int(obj2, &val3);
18254 if (!SWIG_IsOK(ecode3)) {
18255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18256 }
18257 arg3 = static_cast< int >(val3);
18258 ecode4 = SWIG_AsVal_int(obj3, &val4);
18259 if (!SWIG_IsOK(ecode4)) {
18260 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18261 }
18262 arg4 = static_cast< int >(val4);
18263 arg5 = obj4;
18264 {
18265 PyThreadState* __tstate = wxPyBeginAllowThreads();
18266 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18267 wxPyEndAllowThreads(__tstate);
18268 if (PyErr_Occurred()) SWIG_fail;
18269 }
18270 resultobj = SWIG_Py_Void();
18271 return resultobj;
18272 fail:
18273 return NULL;
18274 }
18275
18276
18277 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18278 PyObject *resultobj = 0;
18279 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18280 int arg2 ;
18281 int arg3 = (int) -1 ;
18282 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18283 bool result;
18284 void *argp1 = 0 ;
18285 int res1 = 0 ;
18286 int val2 ;
18287 int ecode2 = 0 ;
18288 int val3 ;
18289 int ecode3 = 0 ;
18290 int val4 ;
18291 int ecode4 = 0 ;
18292 PyObject * obj0 = 0 ;
18293 PyObject * obj1 = 0 ;
18294 PyObject * obj2 = 0 ;
18295 PyObject * obj3 = 0 ;
18296 char * kwnames[] = {
18297 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18298 };
18299
18300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18302 if (!SWIG_IsOK(res1)) {
18303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18304 }
18305 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18306 ecode2 = SWIG_AsVal_int(obj1, &val2);
18307 if (!SWIG_IsOK(ecode2)) {
18308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18309 }
18310 arg2 = static_cast< int >(val2);
18311 if (obj2) {
18312 ecode3 = SWIG_AsVal_int(obj2, &val3);
18313 if (!SWIG_IsOK(ecode3)) {
18314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18315 }
18316 arg3 = static_cast< int >(val3);
18317 }
18318 if (obj3) {
18319 ecode4 = SWIG_AsVal_int(obj3, &val4);
18320 if (!SWIG_IsOK(ecode4)) {
18321 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18322 }
18323 arg4 = static_cast< wxEventType >(val4);
18324 }
18325 {
18326 PyThreadState* __tstate = wxPyBeginAllowThreads();
18327 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18328 wxPyEndAllowThreads(__tstate);
18329 if (PyErr_Occurred()) SWIG_fail;
18330 }
18331 {
18332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18333 }
18334 return resultobj;
18335 fail:
18336 return NULL;
18337 }
18338
18339
18340 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18341 PyObject *resultobj = 0;
18342 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18343 PyObject *arg2 = (PyObject *) 0 ;
18344 bool arg3 = (bool) true ;
18345 void *argp1 = 0 ;
18346 int res1 = 0 ;
18347 bool val3 ;
18348 int ecode3 = 0 ;
18349 PyObject * obj0 = 0 ;
18350 PyObject * obj1 = 0 ;
18351 PyObject * obj2 = 0 ;
18352 char * kwnames[] = {
18353 (char *) "self",(char *) "_self",(char *) "incref", NULL
18354 };
18355
18356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18358 if (!SWIG_IsOK(res1)) {
18359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18360 }
18361 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18362 arg2 = obj1;
18363 if (obj2) {
18364 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18365 if (!SWIG_IsOK(ecode3)) {
18366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18367 }
18368 arg3 = static_cast< bool >(val3);
18369 }
18370 {
18371 PyThreadState* __tstate = wxPyBeginAllowThreads();
18372 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18373 wxPyEndAllowThreads(__tstate);
18374 if (PyErr_Occurred()) SWIG_fail;
18375 }
18376 resultobj = SWIG_Py_Void();
18377 return resultobj;
18378 fail:
18379 return NULL;
18380 }
18381
18382
18383 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18384 PyObject *obj;
18385 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18386 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18387 return SWIG_Py_Void();
18388 }
18389
18390 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18391 return SWIG_Python_InitShadowInstance(args);
18392 }
18393
18394 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18395 PyObject *resultobj = 0;
18396 wxEventType result;
18397
18398 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18399 {
18400 PyThreadState* __tstate = wxPyBeginAllowThreads();
18401 result = (wxEventType)wxNewEventType();
18402 wxPyEndAllowThreads(__tstate);
18403 if (PyErr_Occurred()) SWIG_fail;
18404 }
18405 resultobj = SWIG_From_int(static_cast< int >(result));
18406 return resultobj;
18407 fail:
18408 return NULL;
18409 }
18410
18411
18412 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18413 PyObject *resultobj = 0;
18414 wxEvent *arg1 = (wxEvent *) 0 ;
18415 void *argp1 = 0 ;
18416 int res1 = 0 ;
18417 PyObject *swig_obj[1] ;
18418
18419 if (!args) SWIG_fail;
18420 swig_obj[0] = args;
18421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18422 if (!SWIG_IsOK(res1)) {
18423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18424 }
18425 arg1 = reinterpret_cast< wxEvent * >(argp1);
18426 {
18427 PyThreadState* __tstate = wxPyBeginAllowThreads();
18428 delete arg1;
18429
18430 wxPyEndAllowThreads(__tstate);
18431 if (PyErr_Occurred()) SWIG_fail;
18432 }
18433 resultobj = SWIG_Py_Void();
18434 return resultobj;
18435 fail:
18436 return NULL;
18437 }
18438
18439
18440 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18441 PyObject *resultobj = 0;
18442 wxEvent *arg1 = (wxEvent *) 0 ;
18443 wxEventType arg2 ;
18444 void *argp1 = 0 ;
18445 int res1 = 0 ;
18446 int val2 ;
18447 int ecode2 = 0 ;
18448 PyObject * obj0 = 0 ;
18449 PyObject * obj1 = 0 ;
18450 char * kwnames[] = {
18451 (char *) "self",(char *) "typ", NULL
18452 };
18453
18454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18456 if (!SWIG_IsOK(res1)) {
18457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18458 }
18459 arg1 = reinterpret_cast< wxEvent * >(argp1);
18460 ecode2 = SWIG_AsVal_int(obj1, &val2);
18461 if (!SWIG_IsOK(ecode2)) {
18462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18463 }
18464 arg2 = static_cast< wxEventType >(val2);
18465 {
18466 PyThreadState* __tstate = wxPyBeginAllowThreads();
18467 (arg1)->SetEventType(arg2);
18468 wxPyEndAllowThreads(__tstate);
18469 if (PyErr_Occurred()) SWIG_fail;
18470 }
18471 resultobj = SWIG_Py_Void();
18472 return resultobj;
18473 fail:
18474 return NULL;
18475 }
18476
18477
18478 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18479 PyObject *resultobj = 0;
18480 wxEvent *arg1 = (wxEvent *) 0 ;
18481 wxEventType result;
18482 void *argp1 = 0 ;
18483 int res1 = 0 ;
18484 PyObject *swig_obj[1] ;
18485
18486 if (!args) SWIG_fail;
18487 swig_obj[0] = args;
18488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18489 if (!SWIG_IsOK(res1)) {
18490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18491 }
18492 arg1 = reinterpret_cast< wxEvent * >(argp1);
18493 {
18494 PyThreadState* __tstate = wxPyBeginAllowThreads();
18495 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18496 wxPyEndAllowThreads(__tstate);
18497 if (PyErr_Occurred()) SWIG_fail;
18498 }
18499 resultobj = SWIG_From_int(static_cast< int >(result));
18500 return resultobj;
18501 fail:
18502 return NULL;
18503 }
18504
18505
18506 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18507 PyObject *resultobj = 0;
18508 wxEvent *arg1 = (wxEvent *) 0 ;
18509 wxObject *result = 0 ;
18510 void *argp1 = 0 ;
18511 int res1 = 0 ;
18512 PyObject *swig_obj[1] ;
18513
18514 if (!args) SWIG_fail;
18515 swig_obj[0] = args;
18516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18517 if (!SWIG_IsOK(res1)) {
18518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18519 }
18520 arg1 = reinterpret_cast< wxEvent * >(argp1);
18521 {
18522 PyThreadState* __tstate = wxPyBeginAllowThreads();
18523 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18524 wxPyEndAllowThreads(__tstate);
18525 if (PyErr_Occurred()) SWIG_fail;
18526 }
18527 {
18528 resultobj = wxPyMake_wxObject(result, (bool)0);
18529 }
18530 return resultobj;
18531 fail:
18532 return NULL;
18533 }
18534
18535
18536 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18537 PyObject *resultobj = 0;
18538 wxEvent *arg1 = (wxEvent *) 0 ;
18539 wxObject *arg2 = (wxObject *) 0 ;
18540 void *argp1 = 0 ;
18541 int res1 = 0 ;
18542 void *argp2 = 0 ;
18543 int res2 = 0 ;
18544 PyObject * obj0 = 0 ;
18545 PyObject * obj1 = 0 ;
18546 char * kwnames[] = {
18547 (char *) "self",(char *) "obj", NULL
18548 };
18549
18550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18552 if (!SWIG_IsOK(res1)) {
18553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18554 }
18555 arg1 = reinterpret_cast< wxEvent * >(argp1);
18556 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18557 if (!SWIG_IsOK(res2)) {
18558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18559 }
18560 arg2 = reinterpret_cast< wxObject * >(argp2);
18561 {
18562 PyThreadState* __tstate = wxPyBeginAllowThreads();
18563 (arg1)->SetEventObject(arg2);
18564 wxPyEndAllowThreads(__tstate);
18565 if (PyErr_Occurred()) SWIG_fail;
18566 }
18567 resultobj = SWIG_Py_Void();
18568 return resultobj;
18569 fail:
18570 return NULL;
18571 }
18572
18573
18574 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18575 PyObject *resultobj = 0;
18576 wxEvent *arg1 = (wxEvent *) 0 ;
18577 long result;
18578 void *argp1 = 0 ;
18579 int res1 = 0 ;
18580 PyObject *swig_obj[1] ;
18581
18582 if (!args) SWIG_fail;
18583 swig_obj[0] = args;
18584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18585 if (!SWIG_IsOK(res1)) {
18586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18587 }
18588 arg1 = reinterpret_cast< wxEvent * >(argp1);
18589 {
18590 PyThreadState* __tstate = wxPyBeginAllowThreads();
18591 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18592 wxPyEndAllowThreads(__tstate);
18593 if (PyErr_Occurred()) SWIG_fail;
18594 }
18595 resultobj = SWIG_From_long(static_cast< long >(result));
18596 return resultobj;
18597 fail:
18598 return NULL;
18599 }
18600
18601
18602 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18603 PyObject *resultobj = 0;
18604 wxEvent *arg1 = (wxEvent *) 0 ;
18605 long arg2 = (long) 0 ;
18606 void *argp1 = 0 ;
18607 int res1 = 0 ;
18608 long val2 ;
18609 int ecode2 = 0 ;
18610 PyObject * obj0 = 0 ;
18611 PyObject * obj1 = 0 ;
18612 char * kwnames[] = {
18613 (char *) "self",(char *) "ts", NULL
18614 };
18615
18616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18618 if (!SWIG_IsOK(res1)) {
18619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18620 }
18621 arg1 = reinterpret_cast< wxEvent * >(argp1);
18622 if (obj1) {
18623 ecode2 = SWIG_AsVal_long(obj1, &val2);
18624 if (!SWIG_IsOK(ecode2)) {
18625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18626 }
18627 arg2 = static_cast< long >(val2);
18628 }
18629 {
18630 PyThreadState* __tstate = wxPyBeginAllowThreads();
18631 (arg1)->SetTimestamp(arg2);
18632 wxPyEndAllowThreads(__tstate);
18633 if (PyErr_Occurred()) SWIG_fail;
18634 }
18635 resultobj = SWIG_Py_Void();
18636 return resultobj;
18637 fail:
18638 return NULL;
18639 }
18640
18641
18642 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18643 PyObject *resultobj = 0;
18644 wxEvent *arg1 = (wxEvent *) 0 ;
18645 int result;
18646 void *argp1 = 0 ;
18647 int res1 = 0 ;
18648 PyObject *swig_obj[1] ;
18649
18650 if (!args) SWIG_fail;
18651 swig_obj[0] = args;
18652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18653 if (!SWIG_IsOK(res1)) {
18654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18655 }
18656 arg1 = reinterpret_cast< wxEvent * >(argp1);
18657 {
18658 PyThreadState* __tstate = wxPyBeginAllowThreads();
18659 result = (int)((wxEvent const *)arg1)->GetId();
18660 wxPyEndAllowThreads(__tstate);
18661 if (PyErr_Occurred()) SWIG_fail;
18662 }
18663 resultobj = SWIG_From_int(static_cast< int >(result));
18664 return resultobj;
18665 fail:
18666 return NULL;
18667 }
18668
18669
18670 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18671 PyObject *resultobj = 0;
18672 wxEvent *arg1 = (wxEvent *) 0 ;
18673 int arg2 ;
18674 void *argp1 = 0 ;
18675 int res1 = 0 ;
18676 int val2 ;
18677 int ecode2 = 0 ;
18678 PyObject * obj0 = 0 ;
18679 PyObject * obj1 = 0 ;
18680 char * kwnames[] = {
18681 (char *) "self",(char *) "Id", NULL
18682 };
18683
18684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18686 if (!SWIG_IsOK(res1)) {
18687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18688 }
18689 arg1 = reinterpret_cast< wxEvent * >(argp1);
18690 ecode2 = SWIG_AsVal_int(obj1, &val2);
18691 if (!SWIG_IsOK(ecode2)) {
18692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18693 }
18694 arg2 = static_cast< int >(val2);
18695 {
18696 PyThreadState* __tstate = wxPyBeginAllowThreads();
18697 (arg1)->SetId(arg2);
18698 wxPyEndAllowThreads(__tstate);
18699 if (PyErr_Occurred()) SWIG_fail;
18700 }
18701 resultobj = SWIG_Py_Void();
18702 return resultobj;
18703 fail:
18704 return NULL;
18705 }
18706
18707
18708 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18709 PyObject *resultobj = 0;
18710 wxEvent *arg1 = (wxEvent *) 0 ;
18711 bool result;
18712 void *argp1 = 0 ;
18713 int res1 = 0 ;
18714 PyObject *swig_obj[1] ;
18715
18716 if (!args) SWIG_fail;
18717 swig_obj[0] = args;
18718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18719 if (!SWIG_IsOK(res1)) {
18720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18721 }
18722 arg1 = reinterpret_cast< wxEvent * >(argp1);
18723 {
18724 PyThreadState* __tstate = wxPyBeginAllowThreads();
18725 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18726 wxPyEndAllowThreads(__tstate);
18727 if (PyErr_Occurred()) SWIG_fail;
18728 }
18729 {
18730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18731 }
18732 return resultobj;
18733 fail:
18734 return NULL;
18735 }
18736
18737
18738 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18739 PyObject *resultobj = 0;
18740 wxEvent *arg1 = (wxEvent *) 0 ;
18741 bool arg2 = (bool) true ;
18742 void *argp1 = 0 ;
18743 int res1 = 0 ;
18744 bool val2 ;
18745 int ecode2 = 0 ;
18746 PyObject * obj0 = 0 ;
18747 PyObject * obj1 = 0 ;
18748 char * kwnames[] = {
18749 (char *) "self",(char *) "skip", NULL
18750 };
18751
18752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18754 if (!SWIG_IsOK(res1)) {
18755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18756 }
18757 arg1 = reinterpret_cast< wxEvent * >(argp1);
18758 if (obj1) {
18759 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18760 if (!SWIG_IsOK(ecode2)) {
18761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18762 }
18763 arg2 = static_cast< bool >(val2);
18764 }
18765 {
18766 PyThreadState* __tstate = wxPyBeginAllowThreads();
18767 (arg1)->Skip(arg2);
18768 wxPyEndAllowThreads(__tstate);
18769 if (PyErr_Occurred()) SWIG_fail;
18770 }
18771 resultobj = SWIG_Py_Void();
18772 return resultobj;
18773 fail:
18774 return NULL;
18775 }
18776
18777
18778 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18779 PyObject *resultobj = 0;
18780 wxEvent *arg1 = (wxEvent *) 0 ;
18781 bool result;
18782 void *argp1 = 0 ;
18783 int res1 = 0 ;
18784 PyObject *swig_obj[1] ;
18785
18786 if (!args) SWIG_fail;
18787 swig_obj[0] = args;
18788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18789 if (!SWIG_IsOK(res1)) {
18790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18791 }
18792 arg1 = reinterpret_cast< wxEvent * >(argp1);
18793 {
18794 PyThreadState* __tstate = wxPyBeginAllowThreads();
18795 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18796 wxPyEndAllowThreads(__tstate);
18797 if (PyErr_Occurred()) SWIG_fail;
18798 }
18799 {
18800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18801 }
18802 return resultobj;
18803 fail:
18804 return NULL;
18805 }
18806
18807
18808 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18809 PyObject *resultobj = 0;
18810 wxEvent *arg1 = (wxEvent *) 0 ;
18811 bool result;
18812 void *argp1 = 0 ;
18813 int res1 = 0 ;
18814 PyObject *swig_obj[1] ;
18815
18816 if (!args) SWIG_fail;
18817 swig_obj[0] = args;
18818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18819 if (!SWIG_IsOK(res1)) {
18820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18821 }
18822 arg1 = reinterpret_cast< wxEvent * >(argp1);
18823 {
18824 PyThreadState* __tstate = wxPyBeginAllowThreads();
18825 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18826 wxPyEndAllowThreads(__tstate);
18827 if (PyErr_Occurred()) SWIG_fail;
18828 }
18829 {
18830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18831 }
18832 return resultobj;
18833 fail:
18834 return NULL;
18835 }
18836
18837
18838 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18839 PyObject *resultobj = 0;
18840 wxEvent *arg1 = (wxEvent *) 0 ;
18841 int result;
18842 void *argp1 = 0 ;
18843 int res1 = 0 ;
18844 PyObject *swig_obj[1] ;
18845
18846 if (!args) SWIG_fail;
18847 swig_obj[0] = args;
18848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18849 if (!SWIG_IsOK(res1)) {
18850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18851 }
18852 arg1 = reinterpret_cast< wxEvent * >(argp1);
18853 {
18854 PyThreadState* __tstate = wxPyBeginAllowThreads();
18855 result = (int)(arg1)->StopPropagation();
18856 wxPyEndAllowThreads(__tstate);
18857 if (PyErr_Occurred()) SWIG_fail;
18858 }
18859 resultobj = SWIG_From_int(static_cast< int >(result));
18860 return resultobj;
18861 fail:
18862 return NULL;
18863 }
18864
18865
18866 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18867 PyObject *resultobj = 0;
18868 wxEvent *arg1 = (wxEvent *) 0 ;
18869 int arg2 ;
18870 void *argp1 = 0 ;
18871 int res1 = 0 ;
18872 int val2 ;
18873 int ecode2 = 0 ;
18874 PyObject * obj0 = 0 ;
18875 PyObject * obj1 = 0 ;
18876 char * kwnames[] = {
18877 (char *) "self",(char *) "propagationLevel", NULL
18878 };
18879
18880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18882 if (!SWIG_IsOK(res1)) {
18883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18884 }
18885 arg1 = reinterpret_cast< wxEvent * >(argp1);
18886 ecode2 = SWIG_AsVal_int(obj1, &val2);
18887 if (!SWIG_IsOK(ecode2)) {
18888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18889 }
18890 arg2 = static_cast< int >(val2);
18891 {
18892 PyThreadState* __tstate = wxPyBeginAllowThreads();
18893 (arg1)->ResumePropagation(arg2);
18894 wxPyEndAllowThreads(__tstate);
18895 if (PyErr_Occurred()) SWIG_fail;
18896 }
18897 resultobj = SWIG_Py_Void();
18898 return resultobj;
18899 fail:
18900 return NULL;
18901 }
18902
18903
18904 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18905 PyObject *resultobj = 0;
18906 wxEvent *arg1 = (wxEvent *) 0 ;
18907 wxEvent *result = 0 ;
18908 void *argp1 = 0 ;
18909 int res1 = 0 ;
18910 PyObject *swig_obj[1] ;
18911
18912 if (!args) SWIG_fail;
18913 swig_obj[0] = args;
18914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18915 if (!SWIG_IsOK(res1)) {
18916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18917 }
18918 arg1 = reinterpret_cast< wxEvent * >(argp1);
18919 {
18920 PyThreadState* __tstate = wxPyBeginAllowThreads();
18921 result = (wxEvent *)(arg1)->Clone();
18922 wxPyEndAllowThreads(__tstate);
18923 if (PyErr_Occurred()) SWIG_fail;
18924 }
18925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18926 return resultobj;
18927 fail:
18928 return NULL;
18929 }
18930
18931
18932 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18933 PyObject *obj;
18934 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18935 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18936 return SWIG_Py_Void();
18937 }
18938
18939 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18940 PyObject *resultobj = 0;
18941 wxEvent *arg1 = 0 ;
18942 wxPropagationDisabler *result = 0 ;
18943 void *argp1 = 0 ;
18944 int res1 = 0 ;
18945 PyObject * obj0 = 0 ;
18946 char * kwnames[] = {
18947 (char *) "event", NULL
18948 };
18949
18950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18951 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18952 if (!SWIG_IsOK(res1)) {
18953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18954 }
18955 if (!argp1) {
18956 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18957 }
18958 arg1 = reinterpret_cast< wxEvent * >(argp1);
18959 {
18960 PyThreadState* __tstate = wxPyBeginAllowThreads();
18961 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18962 wxPyEndAllowThreads(__tstate);
18963 if (PyErr_Occurred()) SWIG_fail;
18964 }
18965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18966 return resultobj;
18967 fail:
18968 return NULL;
18969 }
18970
18971
18972 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18973 PyObject *resultobj = 0;
18974 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18975 void *argp1 = 0 ;
18976 int res1 = 0 ;
18977 PyObject *swig_obj[1] ;
18978
18979 if (!args) SWIG_fail;
18980 swig_obj[0] = args;
18981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18982 if (!SWIG_IsOK(res1)) {
18983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18984 }
18985 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18986 {
18987 PyThreadState* __tstate = wxPyBeginAllowThreads();
18988 delete arg1;
18989
18990 wxPyEndAllowThreads(__tstate);
18991 if (PyErr_Occurred()) SWIG_fail;
18992 }
18993 resultobj = SWIG_Py_Void();
18994 return resultobj;
18995 fail:
18996 return NULL;
18997 }
18998
18999
19000 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19001 PyObject *obj;
19002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19003 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19004 return SWIG_Py_Void();
19005 }
19006
19007 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19008 return SWIG_Python_InitShadowInstance(args);
19009 }
19010
19011 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19012 PyObject *resultobj = 0;
19013 wxEvent *arg1 = 0 ;
19014 wxPropagateOnce *result = 0 ;
19015 void *argp1 = 0 ;
19016 int res1 = 0 ;
19017 PyObject * obj0 = 0 ;
19018 char * kwnames[] = {
19019 (char *) "event", NULL
19020 };
19021
19022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19023 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19024 if (!SWIG_IsOK(res1)) {
19025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19026 }
19027 if (!argp1) {
19028 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19029 }
19030 arg1 = reinterpret_cast< wxEvent * >(argp1);
19031 {
19032 PyThreadState* __tstate = wxPyBeginAllowThreads();
19033 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19034 wxPyEndAllowThreads(__tstate);
19035 if (PyErr_Occurred()) SWIG_fail;
19036 }
19037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19038 return resultobj;
19039 fail:
19040 return NULL;
19041 }
19042
19043
19044 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19045 PyObject *resultobj = 0;
19046 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19047 void *argp1 = 0 ;
19048 int res1 = 0 ;
19049 PyObject *swig_obj[1] ;
19050
19051 if (!args) SWIG_fail;
19052 swig_obj[0] = args;
19053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19054 if (!SWIG_IsOK(res1)) {
19055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19056 }
19057 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19058 {
19059 PyThreadState* __tstate = wxPyBeginAllowThreads();
19060 delete arg1;
19061
19062 wxPyEndAllowThreads(__tstate);
19063 if (PyErr_Occurred()) SWIG_fail;
19064 }
19065 resultobj = SWIG_Py_Void();
19066 return resultobj;
19067 fail:
19068 return NULL;
19069 }
19070
19071
19072 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19073 PyObject *obj;
19074 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19075 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19076 return SWIG_Py_Void();
19077 }
19078
19079 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19080 return SWIG_Python_InitShadowInstance(args);
19081 }
19082
19083 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19084 PyObject *resultobj = 0;
19085 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19086 int arg2 = (int) 0 ;
19087 wxCommandEvent *result = 0 ;
19088 int val1 ;
19089 int ecode1 = 0 ;
19090 int val2 ;
19091 int ecode2 = 0 ;
19092 PyObject * obj0 = 0 ;
19093 PyObject * obj1 = 0 ;
19094 char * kwnames[] = {
19095 (char *) "commandType",(char *) "winid", NULL
19096 };
19097
19098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19099 if (obj0) {
19100 ecode1 = SWIG_AsVal_int(obj0, &val1);
19101 if (!SWIG_IsOK(ecode1)) {
19102 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19103 }
19104 arg1 = static_cast< wxEventType >(val1);
19105 }
19106 if (obj1) {
19107 ecode2 = SWIG_AsVal_int(obj1, &val2);
19108 if (!SWIG_IsOK(ecode2)) {
19109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19110 }
19111 arg2 = static_cast< int >(val2);
19112 }
19113 {
19114 PyThreadState* __tstate = wxPyBeginAllowThreads();
19115 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19116 wxPyEndAllowThreads(__tstate);
19117 if (PyErr_Occurred()) SWIG_fail;
19118 }
19119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19120 return resultobj;
19121 fail:
19122 return NULL;
19123 }
19124
19125
19126 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19127 PyObject *resultobj = 0;
19128 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19129 int result;
19130 void *argp1 = 0 ;
19131 int res1 = 0 ;
19132 PyObject *swig_obj[1] ;
19133
19134 if (!args) SWIG_fail;
19135 swig_obj[0] = args;
19136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19137 if (!SWIG_IsOK(res1)) {
19138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19139 }
19140 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19141 {
19142 PyThreadState* __tstate = wxPyBeginAllowThreads();
19143 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19144 wxPyEndAllowThreads(__tstate);
19145 if (PyErr_Occurred()) SWIG_fail;
19146 }
19147 resultobj = SWIG_From_int(static_cast< int >(result));
19148 return resultobj;
19149 fail:
19150 return NULL;
19151 }
19152
19153
19154 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19155 PyObject *resultobj = 0;
19156 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19157 wxString *arg2 = 0 ;
19158 void *argp1 = 0 ;
19159 int res1 = 0 ;
19160 bool temp2 = false ;
19161 PyObject * obj0 = 0 ;
19162 PyObject * obj1 = 0 ;
19163 char * kwnames[] = {
19164 (char *) "self",(char *) "s", NULL
19165 };
19166
19167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19169 if (!SWIG_IsOK(res1)) {
19170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19171 }
19172 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19173 {
19174 arg2 = wxString_in_helper(obj1);
19175 if (arg2 == NULL) SWIG_fail;
19176 temp2 = true;
19177 }
19178 {
19179 PyThreadState* __tstate = wxPyBeginAllowThreads();
19180 (arg1)->SetString((wxString const &)*arg2);
19181 wxPyEndAllowThreads(__tstate);
19182 if (PyErr_Occurred()) SWIG_fail;
19183 }
19184 resultobj = SWIG_Py_Void();
19185 {
19186 if (temp2)
19187 delete arg2;
19188 }
19189 return resultobj;
19190 fail:
19191 {
19192 if (temp2)
19193 delete arg2;
19194 }
19195 return NULL;
19196 }
19197
19198
19199 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19200 PyObject *resultobj = 0;
19201 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19202 wxString result;
19203 void *argp1 = 0 ;
19204 int res1 = 0 ;
19205 PyObject *swig_obj[1] ;
19206
19207 if (!args) SWIG_fail;
19208 swig_obj[0] = args;
19209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19210 if (!SWIG_IsOK(res1)) {
19211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19212 }
19213 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19214 {
19215 PyThreadState* __tstate = wxPyBeginAllowThreads();
19216 result = ((wxCommandEvent const *)arg1)->GetString();
19217 wxPyEndAllowThreads(__tstate);
19218 if (PyErr_Occurred()) SWIG_fail;
19219 }
19220 {
19221 #if wxUSE_UNICODE
19222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19223 #else
19224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19225 #endif
19226 }
19227 return resultobj;
19228 fail:
19229 return NULL;
19230 }
19231
19232
19233 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19234 PyObject *resultobj = 0;
19235 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19236 bool result;
19237 void *argp1 = 0 ;
19238 int res1 = 0 ;
19239 PyObject *swig_obj[1] ;
19240
19241 if (!args) SWIG_fail;
19242 swig_obj[0] = args;
19243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19244 if (!SWIG_IsOK(res1)) {
19245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19246 }
19247 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19248 {
19249 PyThreadState* __tstate = wxPyBeginAllowThreads();
19250 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19251 wxPyEndAllowThreads(__tstate);
19252 if (PyErr_Occurred()) SWIG_fail;
19253 }
19254 {
19255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19256 }
19257 return resultobj;
19258 fail:
19259 return NULL;
19260 }
19261
19262
19263 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19264 PyObject *resultobj = 0;
19265 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19266 bool result;
19267 void *argp1 = 0 ;
19268 int res1 = 0 ;
19269 PyObject *swig_obj[1] ;
19270
19271 if (!args) SWIG_fail;
19272 swig_obj[0] = args;
19273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19274 if (!SWIG_IsOK(res1)) {
19275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19276 }
19277 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19278 {
19279 PyThreadState* __tstate = wxPyBeginAllowThreads();
19280 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19281 wxPyEndAllowThreads(__tstate);
19282 if (PyErr_Occurred()) SWIG_fail;
19283 }
19284 {
19285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19286 }
19287 return resultobj;
19288 fail:
19289 return NULL;
19290 }
19291
19292
19293 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19294 PyObject *resultobj = 0;
19295 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19296 long arg2 ;
19297 void *argp1 = 0 ;
19298 int res1 = 0 ;
19299 long val2 ;
19300 int ecode2 = 0 ;
19301 PyObject * obj0 = 0 ;
19302 PyObject * obj1 = 0 ;
19303 char * kwnames[] = {
19304 (char *) "self",(char *) "extraLong", NULL
19305 };
19306
19307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19309 if (!SWIG_IsOK(res1)) {
19310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19311 }
19312 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19313 ecode2 = SWIG_AsVal_long(obj1, &val2);
19314 if (!SWIG_IsOK(ecode2)) {
19315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19316 }
19317 arg2 = static_cast< long >(val2);
19318 {
19319 PyThreadState* __tstate = wxPyBeginAllowThreads();
19320 (arg1)->SetExtraLong(arg2);
19321 wxPyEndAllowThreads(__tstate);
19322 if (PyErr_Occurred()) SWIG_fail;
19323 }
19324 resultobj = SWIG_Py_Void();
19325 return resultobj;
19326 fail:
19327 return NULL;
19328 }
19329
19330
19331 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19332 PyObject *resultobj = 0;
19333 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19334 long result;
19335 void *argp1 = 0 ;
19336 int res1 = 0 ;
19337 PyObject *swig_obj[1] ;
19338
19339 if (!args) SWIG_fail;
19340 swig_obj[0] = args;
19341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19342 if (!SWIG_IsOK(res1)) {
19343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19344 }
19345 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19346 {
19347 PyThreadState* __tstate = wxPyBeginAllowThreads();
19348 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19349 wxPyEndAllowThreads(__tstate);
19350 if (PyErr_Occurred()) SWIG_fail;
19351 }
19352 resultobj = SWIG_From_long(static_cast< long >(result));
19353 return resultobj;
19354 fail:
19355 return NULL;
19356 }
19357
19358
19359 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19360 PyObject *resultobj = 0;
19361 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19362 int arg2 ;
19363 void *argp1 = 0 ;
19364 int res1 = 0 ;
19365 int val2 ;
19366 int ecode2 = 0 ;
19367 PyObject * obj0 = 0 ;
19368 PyObject * obj1 = 0 ;
19369 char * kwnames[] = {
19370 (char *) "self",(char *) "i", NULL
19371 };
19372
19373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19375 if (!SWIG_IsOK(res1)) {
19376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19377 }
19378 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19379 ecode2 = SWIG_AsVal_int(obj1, &val2);
19380 if (!SWIG_IsOK(ecode2)) {
19381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19382 }
19383 arg2 = static_cast< int >(val2);
19384 {
19385 PyThreadState* __tstate = wxPyBeginAllowThreads();
19386 (arg1)->SetInt(arg2);
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_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19398 PyObject *resultobj = 0;
19399 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19400 int result;
19401 void *argp1 = 0 ;
19402 int res1 = 0 ;
19403 PyObject *swig_obj[1] ;
19404
19405 if (!args) SWIG_fail;
19406 swig_obj[0] = args;
19407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19408 if (!SWIG_IsOK(res1)) {
19409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19410 }
19411 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19412 {
19413 PyThreadState* __tstate = wxPyBeginAllowThreads();
19414 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19415 wxPyEndAllowThreads(__tstate);
19416 if (PyErr_Occurred()) SWIG_fail;
19417 }
19418 resultobj = SWIG_From_int(static_cast< int >(result));
19419 return resultobj;
19420 fail:
19421 return NULL;
19422 }
19423
19424
19425 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19426 PyObject *resultobj = 0;
19427 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19428 PyObject *result = 0 ;
19429 void *argp1 = 0 ;
19430 int res1 = 0 ;
19431 PyObject *swig_obj[1] ;
19432
19433 if (!args) SWIG_fail;
19434 swig_obj[0] = args;
19435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19436 if (!SWIG_IsOK(res1)) {
19437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19438 }
19439 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19440 {
19441 PyThreadState* __tstate = wxPyBeginAllowThreads();
19442 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19443 wxPyEndAllowThreads(__tstate);
19444 if (PyErr_Occurred()) SWIG_fail;
19445 }
19446 resultobj = result;
19447 return resultobj;
19448 fail:
19449 return NULL;
19450 }
19451
19452
19453 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19454 PyObject *resultobj = 0;
19455 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19456 PyObject *arg2 = (PyObject *) 0 ;
19457 void *argp1 = 0 ;
19458 int res1 = 0 ;
19459 PyObject * obj0 = 0 ;
19460 PyObject * obj1 = 0 ;
19461 char * kwnames[] = {
19462 (char *) "self",(char *) "clientData", NULL
19463 };
19464
19465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19467 if (!SWIG_IsOK(res1)) {
19468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19469 }
19470 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19471 arg2 = obj1;
19472 {
19473 PyThreadState* __tstate = wxPyBeginAllowThreads();
19474 wxCommandEvent_SetClientData(arg1,arg2);
19475 wxPyEndAllowThreads(__tstate);
19476 if (PyErr_Occurred()) SWIG_fail;
19477 }
19478 resultobj = SWIG_Py_Void();
19479 return resultobj;
19480 fail:
19481 return NULL;
19482 }
19483
19484
19485 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19486 PyObject *resultobj = 0;
19487 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19488 wxEvent *result = 0 ;
19489 void *argp1 = 0 ;
19490 int res1 = 0 ;
19491 PyObject *swig_obj[1] ;
19492
19493 if (!args) SWIG_fail;
19494 swig_obj[0] = args;
19495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19496 if (!SWIG_IsOK(res1)) {
19497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19498 }
19499 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19500 {
19501 PyThreadState* __tstate = wxPyBeginAllowThreads();
19502 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19503 wxPyEndAllowThreads(__tstate);
19504 if (PyErr_Occurred()) SWIG_fail;
19505 }
19506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19507 return resultobj;
19508 fail:
19509 return NULL;
19510 }
19511
19512
19513 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19514 PyObject *obj;
19515 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19516 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19517 return SWIG_Py_Void();
19518 }
19519
19520 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19521 return SWIG_Python_InitShadowInstance(args);
19522 }
19523
19524 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19525 PyObject *resultobj = 0;
19526 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19527 int arg2 = (int) 0 ;
19528 wxNotifyEvent *result = 0 ;
19529 int val1 ;
19530 int ecode1 = 0 ;
19531 int val2 ;
19532 int ecode2 = 0 ;
19533 PyObject * obj0 = 0 ;
19534 PyObject * obj1 = 0 ;
19535 char * kwnames[] = {
19536 (char *) "commandType",(char *) "winid", NULL
19537 };
19538
19539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19540 if (obj0) {
19541 ecode1 = SWIG_AsVal_int(obj0, &val1);
19542 if (!SWIG_IsOK(ecode1)) {
19543 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19544 }
19545 arg1 = static_cast< wxEventType >(val1);
19546 }
19547 if (obj1) {
19548 ecode2 = SWIG_AsVal_int(obj1, &val2);
19549 if (!SWIG_IsOK(ecode2)) {
19550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19551 }
19552 arg2 = static_cast< int >(val2);
19553 }
19554 {
19555 PyThreadState* __tstate = wxPyBeginAllowThreads();
19556 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19557 wxPyEndAllowThreads(__tstate);
19558 if (PyErr_Occurred()) SWIG_fail;
19559 }
19560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19561 return resultobj;
19562 fail:
19563 return NULL;
19564 }
19565
19566
19567 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19568 PyObject *resultobj = 0;
19569 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19570 void *argp1 = 0 ;
19571 int res1 = 0 ;
19572 PyObject *swig_obj[1] ;
19573
19574 if (!args) SWIG_fail;
19575 swig_obj[0] = args;
19576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19577 if (!SWIG_IsOK(res1)) {
19578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19579 }
19580 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19581 {
19582 PyThreadState* __tstate = wxPyBeginAllowThreads();
19583 (arg1)->Veto();
19584 wxPyEndAllowThreads(__tstate);
19585 if (PyErr_Occurred()) SWIG_fail;
19586 }
19587 resultobj = SWIG_Py_Void();
19588 return resultobj;
19589 fail:
19590 return NULL;
19591 }
19592
19593
19594 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19595 PyObject *resultobj = 0;
19596 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19597 void *argp1 = 0 ;
19598 int res1 = 0 ;
19599 PyObject *swig_obj[1] ;
19600
19601 if (!args) SWIG_fail;
19602 swig_obj[0] = args;
19603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19604 if (!SWIG_IsOK(res1)) {
19605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19606 }
19607 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19608 {
19609 PyThreadState* __tstate = wxPyBeginAllowThreads();
19610 (arg1)->Allow();
19611 wxPyEndAllowThreads(__tstate);
19612 if (PyErr_Occurred()) SWIG_fail;
19613 }
19614 resultobj = SWIG_Py_Void();
19615 return resultobj;
19616 fail:
19617 return NULL;
19618 }
19619
19620
19621 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19622 PyObject *resultobj = 0;
19623 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19624 bool result;
19625 void *argp1 = 0 ;
19626 int res1 = 0 ;
19627 PyObject *swig_obj[1] ;
19628
19629 if (!args) SWIG_fail;
19630 swig_obj[0] = args;
19631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19632 if (!SWIG_IsOK(res1)) {
19633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19634 }
19635 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19636 {
19637 PyThreadState* __tstate = wxPyBeginAllowThreads();
19638 result = (bool)(arg1)->IsAllowed();
19639 wxPyEndAllowThreads(__tstate);
19640 if (PyErr_Occurred()) SWIG_fail;
19641 }
19642 {
19643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19644 }
19645 return resultobj;
19646 fail:
19647 return NULL;
19648 }
19649
19650
19651 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19652 PyObject *obj;
19653 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19654 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19655 return SWIG_Py_Void();
19656 }
19657
19658 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19659 return SWIG_Python_InitShadowInstance(args);
19660 }
19661
19662 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19663 PyObject *resultobj = 0;
19664 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19665 int arg2 = (int) 0 ;
19666 int arg3 = (int) 0 ;
19667 int arg4 = (int) 0 ;
19668 wxScrollEvent *result = 0 ;
19669 int val1 ;
19670 int ecode1 = 0 ;
19671 int val2 ;
19672 int ecode2 = 0 ;
19673 int val3 ;
19674 int ecode3 = 0 ;
19675 int val4 ;
19676 int ecode4 = 0 ;
19677 PyObject * obj0 = 0 ;
19678 PyObject * obj1 = 0 ;
19679 PyObject * obj2 = 0 ;
19680 PyObject * obj3 = 0 ;
19681 char * kwnames[] = {
19682 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19683 };
19684
19685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19686 if (obj0) {
19687 ecode1 = SWIG_AsVal_int(obj0, &val1);
19688 if (!SWIG_IsOK(ecode1)) {
19689 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19690 }
19691 arg1 = static_cast< wxEventType >(val1);
19692 }
19693 if (obj1) {
19694 ecode2 = SWIG_AsVal_int(obj1, &val2);
19695 if (!SWIG_IsOK(ecode2)) {
19696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19697 }
19698 arg2 = static_cast< int >(val2);
19699 }
19700 if (obj2) {
19701 ecode3 = SWIG_AsVal_int(obj2, &val3);
19702 if (!SWIG_IsOK(ecode3)) {
19703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19704 }
19705 arg3 = static_cast< int >(val3);
19706 }
19707 if (obj3) {
19708 ecode4 = SWIG_AsVal_int(obj3, &val4);
19709 if (!SWIG_IsOK(ecode4)) {
19710 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19711 }
19712 arg4 = static_cast< int >(val4);
19713 }
19714 {
19715 PyThreadState* __tstate = wxPyBeginAllowThreads();
19716 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19717 wxPyEndAllowThreads(__tstate);
19718 if (PyErr_Occurred()) SWIG_fail;
19719 }
19720 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19721 return resultobj;
19722 fail:
19723 return NULL;
19724 }
19725
19726
19727 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19728 PyObject *resultobj = 0;
19729 wxScrollEvent *arg1 = (wxScrollEvent *) 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_wxScrollEvent, 0 | 0 );
19738 if (!SWIG_IsOK(res1)) {
19739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19740 }
19741 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19742 {
19743 PyThreadState* __tstate = wxPyBeginAllowThreads();
19744 result = (int)((wxScrollEvent 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_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19756 PyObject *resultobj = 0;
19757 wxScrollEvent *arg1 = (wxScrollEvent *) 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_wxScrollEvent, 0 | 0 );
19766 if (!SWIG_IsOK(res1)) {
19767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19768 }
19769 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19770 {
19771 PyThreadState* __tstate = wxPyBeginAllowThreads();
19772 result = (int)((wxScrollEvent 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_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19784 PyObject *resultobj = 0;
19785 wxScrollEvent *arg1 = (wxScrollEvent *) 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:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19799 if (!SWIG_IsOK(res1)) {
19800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19801 }
19802 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19803 ecode2 = SWIG_AsVal_int(obj1, &val2);
19804 if (!SWIG_IsOK(ecode2)) {
19805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_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_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19822 PyObject *resultobj = 0;
19823 wxScrollEvent *arg1 = (wxScrollEvent *) 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:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19837 if (!SWIG_IsOK(res1)) {
19838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19839 }
19840 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19841 ecode2 = SWIG_AsVal_int(obj1, &val2);
19842 if (!SWIG_IsOK(ecode2)) {
19843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_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 *ScrollEvent_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_wxScrollEvent, SWIG_NewClientData(obj));
19863 return SWIG_Py_Void();
19864 }
19865
19866 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19867 return SWIG_Python_InitShadowInstance(args);
19868 }
19869
19870 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19871 PyObject *resultobj = 0;
19872 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19873 int arg2 = (int) 0 ;
19874 int arg3 = (int) 0 ;
19875 wxScrollWinEvent *result = 0 ;
19876 int val1 ;
19877 int ecode1 = 0 ;
19878 int val2 ;
19879 int ecode2 = 0 ;
19880 int val3 ;
19881 int ecode3 = 0 ;
19882 PyObject * obj0 = 0 ;
19883 PyObject * obj1 = 0 ;
19884 PyObject * obj2 = 0 ;
19885 char * kwnames[] = {
19886 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19887 };
19888
19889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19890 if (obj0) {
19891 ecode1 = SWIG_AsVal_int(obj0, &val1);
19892 if (!SWIG_IsOK(ecode1)) {
19893 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19894 }
19895 arg1 = static_cast< wxEventType >(val1);
19896 }
19897 if (obj1) {
19898 ecode2 = SWIG_AsVal_int(obj1, &val2);
19899 if (!SWIG_IsOK(ecode2)) {
19900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19901 }
19902 arg2 = static_cast< int >(val2);
19903 }
19904 if (obj2) {
19905 ecode3 = SWIG_AsVal_int(obj2, &val3);
19906 if (!SWIG_IsOK(ecode3)) {
19907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19908 }
19909 arg3 = static_cast< int >(val3);
19910 }
19911 {
19912 PyThreadState* __tstate = wxPyBeginAllowThreads();
19913 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19914 wxPyEndAllowThreads(__tstate);
19915 if (PyErr_Occurred()) SWIG_fail;
19916 }
19917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19918 return resultobj;
19919 fail:
19920 return NULL;
19921 }
19922
19923
19924 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19925 PyObject *resultobj = 0;
19926 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19927 int result;
19928 void *argp1 = 0 ;
19929 int res1 = 0 ;
19930 PyObject *swig_obj[1] ;
19931
19932 if (!args) SWIG_fail;
19933 swig_obj[0] = args;
19934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19935 if (!SWIG_IsOK(res1)) {
19936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19937 }
19938 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19939 {
19940 PyThreadState* __tstate = wxPyBeginAllowThreads();
19941 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19942 wxPyEndAllowThreads(__tstate);
19943 if (PyErr_Occurred()) SWIG_fail;
19944 }
19945 resultobj = SWIG_From_int(static_cast< int >(result));
19946 return resultobj;
19947 fail:
19948 return NULL;
19949 }
19950
19951
19952 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19953 PyObject *resultobj = 0;
19954 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19955 int result;
19956 void *argp1 = 0 ;
19957 int res1 = 0 ;
19958 PyObject *swig_obj[1] ;
19959
19960 if (!args) SWIG_fail;
19961 swig_obj[0] = args;
19962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19963 if (!SWIG_IsOK(res1)) {
19964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19965 }
19966 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19967 {
19968 PyThreadState* __tstate = wxPyBeginAllowThreads();
19969 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19970 wxPyEndAllowThreads(__tstate);
19971 if (PyErr_Occurred()) SWIG_fail;
19972 }
19973 resultobj = SWIG_From_int(static_cast< int >(result));
19974 return resultobj;
19975 fail:
19976 return NULL;
19977 }
19978
19979
19980 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19981 PyObject *resultobj = 0;
19982 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19983 int arg2 ;
19984 void *argp1 = 0 ;
19985 int res1 = 0 ;
19986 int val2 ;
19987 int ecode2 = 0 ;
19988 PyObject * obj0 = 0 ;
19989 PyObject * obj1 = 0 ;
19990 char * kwnames[] = {
19991 (char *) "self",(char *) "orient", NULL
19992 };
19993
19994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19996 if (!SWIG_IsOK(res1)) {
19997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19998 }
19999 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20000 ecode2 = SWIG_AsVal_int(obj1, &val2);
20001 if (!SWIG_IsOK(ecode2)) {
20002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20003 }
20004 arg2 = static_cast< int >(val2);
20005 {
20006 PyThreadState* __tstate = wxPyBeginAllowThreads();
20007 (arg1)->SetOrientation(arg2);
20008 wxPyEndAllowThreads(__tstate);
20009 if (PyErr_Occurred()) SWIG_fail;
20010 }
20011 resultobj = SWIG_Py_Void();
20012 return resultobj;
20013 fail:
20014 return NULL;
20015 }
20016
20017
20018 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20019 PyObject *resultobj = 0;
20020 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20021 int arg2 ;
20022 void *argp1 = 0 ;
20023 int res1 = 0 ;
20024 int val2 ;
20025 int ecode2 = 0 ;
20026 PyObject * obj0 = 0 ;
20027 PyObject * obj1 = 0 ;
20028 char * kwnames[] = {
20029 (char *) "self",(char *) "pos", NULL
20030 };
20031
20032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20034 if (!SWIG_IsOK(res1)) {
20035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20036 }
20037 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20038 ecode2 = SWIG_AsVal_int(obj1, &val2);
20039 if (!SWIG_IsOK(ecode2)) {
20040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20041 }
20042 arg2 = static_cast< int >(val2);
20043 {
20044 PyThreadState* __tstate = wxPyBeginAllowThreads();
20045 (arg1)->SetPosition(arg2);
20046 wxPyEndAllowThreads(__tstate);
20047 if (PyErr_Occurred()) SWIG_fail;
20048 }
20049 resultobj = SWIG_Py_Void();
20050 return resultobj;
20051 fail:
20052 return NULL;
20053 }
20054
20055
20056 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20057 PyObject *obj;
20058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20059 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20060 return SWIG_Py_Void();
20061 }
20062
20063 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20064 return SWIG_Python_InitShadowInstance(args);
20065 }
20066
20067 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20068 PyObject *resultobj = 0;
20069 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20070 wxMouseEvent *result = 0 ;
20071 int val1 ;
20072 int ecode1 = 0 ;
20073 PyObject * obj0 = 0 ;
20074 char * kwnames[] = {
20075 (char *) "mouseType", NULL
20076 };
20077
20078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20079 if (obj0) {
20080 ecode1 = SWIG_AsVal_int(obj0, &val1);
20081 if (!SWIG_IsOK(ecode1)) {
20082 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20083 }
20084 arg1 = static_cast< wxEventType >(val1);
20085 }
20086 {
20087 PyThreadState* __tstate = wxPyBeginAllowThreads();
20088 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20089 wxPyEndAllowThreads(__tstate);
20090 if (PyErr_Occurred()) SWIG_fail;
20091 }
20092 {
20093 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20094 }
20095 return resultobj;
20096 fail:
20097 return NULL;
20098 }
20099
20100
20101 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20102 PyObject *resultobj = 0;
20103 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20104 bool result;
20105 void *argp1 = 0 ;
20106 int res1 = 0 ;
20107 PyObject *swig_obj[1] ;
20108
20109 if (!args) SWIG_fail;
20110 swig_obj[0] = args;
20111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20112 if (!SWIG_IsOK(res1)) {
20113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20114 }
20115 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20116 {
20117 PyThreadState* __tstate = wxPyBeginAllowThreads();
20118 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20119 wxPyEndAllowThreads(__tstate);
20120 if (PyErr_Occurred()) SWIG_fail;
20121 }
20122 {
20123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20124 }
20125 return resultobj;
20126 fail:
20127 return NULL;
20128 }
20129
20130
20131 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20132 PyObject *resultobj = 0;
20133 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20134 int arg2 = (int) wxMOUSE_BTN_ANY ;
20135 bool result;
20136 void *argp1 = 0 ;
20137 int res1 = 0 ;
20138 int val2 ;
20139 int ecode2 = 0 ;
20140 PyObject * obj0 = 0 ;
20141 PyObject * obj1 = 0 ;
20142 char * kwnames[] = {
20143 (char *) "self",(char *) "but", NULL
20144 };
20145
20146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20148 if (!SWIG_IsOK(res1)) {
20149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20150 }
20151 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20152 if (obj1) {
20153 ecode2 = SWIG_AsVal_int(obj1, &val2);
20154 if (!SWIG_IsOK(ecode2)) {
20155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20156 }
20157 arg2 = static_cast< int >(val2);
20158 }
20159 {
20160 PyThreadState* __tstate = wxPyBeginAllowThreads();
20161 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20162 wxPyEndAllowThreads(__tstate);
20163 if (PyErr_Occurred()) SWIG_fail;
20164 }
20165 {
20166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20167 }
20168 return resultobj;
20169 fail:
20170 return NULL;
20171 }
20172
20173
20174 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20175 PyObject *resultobj = 0;
20176 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20177 int arg2 = (int) wxMOUSE_BTN_ANY ;
20178 bool result;
20179 void *argp1 = 0 ;
20180 int res1 = 0 ;
20181 int val2 ;
20182 int ecode2 = 0 ;
20183 PyObject * obj0 = 0 ;
20184 PyObject * obj1 = 0 ;
20185 char * kwnames[] = {
20186 (char *) "self",(char *) "but", NULL
20187 };
20188
20189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20191 if (!SWIG_IsOK(res1)) {
20192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20193 }
20194 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20195 if (obj1) {
20196 ecode2 = SWIG_AsVal_int(obj1, &val2);
20197 if (!SWIG_IsOK(ecode2)) {
20198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20199 }
20200 arg2 = static_cast< int >(val2);
20201 }
20202 {
20203 PyThreadState* __tstate = wxPyBeginAllowThreads();
20204 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20205 wxPyEndAllowThreads(__tstate);
20206 if (PyErr_Occurred()) SWIG_fail;
20207 }
20208 {
20209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20210 }
20211 return resultobj;
20212 fail:
20213 return NULL;
20214 }
20215
20216
20217 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20218 PyObject *resultobj = 0;
20219 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20220 int arg2 = (int) wxMOUSE_BTN_ANY ;
20221 bool result;
20222 void *argp1 = 0 ;
20223 int res1 = 0 ;
20224 int val2 ;
20225 int ecode2 = 0 ;
20226 PyObject * obj0 = 0 ;
20227 PyObject * obj1 = 0 ;
20228 char * kwnames[] = {
20229 (char *) "self",(char *) "but", NULL
20230 };
20231
20232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20234 if (!SWIG_IsOK(res1)) {
20235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20236 }
20237 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20238 if (obj1) {
20239 ecode2 = SWIG_AsVal_int(obj1, &val2);
20240 if (!SWIG_IsOK(ecode2)) {
20241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20242 }
20243 arg2 = static_cast< int >(val2);
20244 }
20245 {
20246 PyThreadState* __tstate = wxPyBeginAllowThreads();
20247 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20248 wxPyEndAllowThreads(__tstate);
20249 if (PyErr_Occurred()) SWIG_fail;
20250 }
20251 {
20252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20253 }
20254 return resultobj;
20255 fail:
20256 return NULL;
20257 }
20258
20259
20260 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20261 PyObject *resultobj = 0;
20262 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20263 int arg2 ;
20264 bool result;
20265 void *argp1 = 0 ;
20266 int res1 = 0 ;
20267 int val2 ;
20268 int ecode2 = 0 ;
20269 PyObject * obj0 = 0 ;
20270 PyObject * obj1 = 0 ;
20271 char * kwnames[] = {
20272 (char *) "self",(char *) "button", NULL
20273 };
20274
20275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20277 if (!SWIG_IsOK(res1)) {
20278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20279 }
20280 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20281 ecode2 = SWIG_AsVal_int(obj1, &val2);
20282 if (!SWIG_IsOK(ecode2)) {
20283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20284 }
20285 arg2 = static_cast< int >(val2);
20286 {
20287 PyThreadState* __tstate = wxPyBeginAllowThreads();
20288 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20289 wxPyEndAllowThreads(__tstate);
20290 if (PyErr_Occurred()) SWIG_fail;
20291 }
20292 {
20293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20294 }
20295 return resultobj;
20296 fail:
20297 return NULL;
20298 }
20299
20300
20301 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20302 PyObject *resultobj = 0;
20303 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20304 int arg2 ;
20305 bool result;
20306 void *argp1 = 0 ;
20307 int res1 = 0 ;
20308 int val2 ;
20309 int ecode2 = 0 ;
20310 PyObject * obj0 = 0 ;
20311 PyObject * obj1 = 0 ;
20312 char * kwnames[] = {
20313 (char *) "self",(char *) "but", NULL
20314 };
20315
20316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20318 if (!SWIG_IsOK(res1)) {
20319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20320 }
20321 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20322 ecode2 = SWIG_AsVal_int(obj1, &val2);
20323 if (!SWIG_IsOK(ecode2)) {
20324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20325 }
20326 arg2 = static_cast< int >(val2);
20327 {
20328 PyThreadState* __tstate = wxPyBeginAllowThreads();
20329 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20330 wxPyEndAllowThreads(__tstate);
20331 if (PyErr_Occurred()) SWIG_fail;
20332 }
20333 {
20334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20335 }
20336 return resultobj;
20337 fail:
20338 return NULL;
20339 }
20340
20341
20342 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20343 PyObject *resultobj = 0;
20344 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20345 int result;
20346 void *argp1 = 0 ;
20347 int res1 = 0 ;
20348 PyObject *swig_obj[1] ;
20349
20350 if (!args) SWIG_fail;
20351 swig_obj[0] = args;
20352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20353 if (!SWIG_IsOK(res1)) {
20354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20355 }
20356 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20357 {
20358 PyThreadState* __tstate = wxPyBeginAllowThreads();
20359 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20360 wxPyEndAllowThreads(__tstate);
20361 if (PyErr_Occurred()) SWIG_fail;
20362 }
20363 resultobj = SWIG_From_int(static_cast< int >(result));
20364 return resultobj;
20365 fail:
20366 return NULL;
20367 }
20368
20369
20370 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20371 PyObject *resultobj = 0;
20372 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20373 bool result;
20374 void *argp1 = 0 ;
20375 int res1 = 0 ;
20376 PyObject *swig_obj[1] ;
20377
20378 if (!args) SWIG_fail;
20379 swig_obj[0] = args;
20380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20381 if (!SWIG_IsOK(res1)) {
20382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20383 }
20384 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20385 {
20386 PyThreadState* __tstate = wxPyBeginAllowThreads();
20387 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20388 wxPyEndAllowThreads(__tstate);
20389 if (PyErr_Occurred()) SWIG_fail;
20390 }
20391 {
20392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20393 }
20394 return resultobj;
20395 fail:
20396 return NULL;
20397 }
20398
20399
20400 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20401 PyObject *resultobj = 0;
20402 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20403 bool result;
20404 void *argp1 = 0 ;
20405 int res1 = 0 ;
20406 PyObject *swig_obj[1] ;
20407
20408 if (!args) SWIG_fail;
20409 swig_obj[0] = args;
20410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20411 if (!SWIG_IsOK(res1)) {
20412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20413 }
20414 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20415 {
20416 PyThreadState* __tstate = wxPyBeginAllowThreads();
20417 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20418 wxPyEndAllowThreads(__tstate);
20419 if (PyErr_Occurred()) SWIG_fail;
20420 }
20421 {
20422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20423 }
20424 return resultobj;
20425 fail:
20426 return NULL;
20427 }
20428
20429
20430 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20431 PyObject *resultobj = 0;
20432 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20433 bool result;
20434 void *argp1 = 0 ;
20435 int res1 = 0 ;
20436 PyObject *swig_obj[1] ;
20437
20438 if (!args) SWIG_fail;
20439 swig_obj[0] = args;
20440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20441 if (!SWIG_IsOK(res1)) {
20442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20443 }
20444 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20445 {
20446 PyThreadState* __tstate = wxPyBeginAllowThreads();
20447 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20448 wxPyEndAllowThreads(__tstate);
20449 if (PyErr_Occurred()) SWIG_fail;
20450 }
20451 {
20452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20453 }
20454 return resultobj;
20455 fail:
20456 return NULL;
20457 }
20458
20459
20460 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20461 PyObject *resultobj = 0;
20462 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20463 bool result;
20464 void *argp1 = 0 ;
20465 int res1 = 0 ;
20466 PyObject *swig_obj[1] ;
20467
20468 if (!args) SWIG_fail;
20469 swig_obj[0] = args;
20470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20471 if (!SWIG_IsOK(res1)) {
20472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20473 }
20474 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20475 {
20476 PyThreadState* __tstate = wxPyBeginAllowThreads();
20477 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20478 wxPyEndAllowThreads(__tstate);
20479 if (PyErr_Occurred()) SWIG_fail;
20480 }
20481 {
20482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20483 }
20484 return resultobj;
20485 fail:
20486 return NULL;
20487 }
20488
20489
20490 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20491 PyObject *resultobj = 0;
20492 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20493 bool result;
20494 void *argp1 = 0 ;
20495 int res1 = 0 ;
20496 PyObject *swig_obj[1] ;
20497
20498 if (!args) SWIG_fail;
20499 swig_obj[0] = args;
20500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20501 if (!SWIG_IsOK(res1)) {
20502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20503 }
20504 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20505 {
20506 PyThreadState* __tstate = wxPyBeginAllowThreads();
20507 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20508 wxPyEndAllowThreads(__tstate);
20509 if (PyErr_Occurred()) SWIG_fail;
20510 }
20511 {
20512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20513 }
20514 return resultobj;
20515 fail:
20516 return NULL;
20517 }
20518
20519
20520 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20521 PyObject *resultobj = 0;
20522 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20523 bool result;
20524 void *argp1 = 0 ;
20525 int res1 = 0 ;
20526 PyObject *swig_obj[1] ;
20527
20528 if (!args) SWIG_fail;
20529 swig_obj[0] = args;
20530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20531 if (!SWIG_IsOK(res1)) {
20532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20533 }
20534 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20535 {
20536 PyThreadState* __tstate = wxPyBeginAllowThreads();
20537 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20538 wxPyEndAllowThreads(__tstate);
20539 if (PyErr_Occurred()) SWIG_fail;
20540 }
20541 {
20542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20543 }
20544 return resultobj;
20545 fail:
20546 return NULL;
20547 }
20548
20549
20550 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20551 PyObject *resultobj = 0;
20552 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20553 bool result;
20554 void *argp1 = 0 ;
20555 int res1 = 0 ;
20556 PyObject *swig_obj[1] ;
20557
20558 if (!args) SWIG_fail;
20559 swig_obj[0] = args;
20560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20561 if (!SWIG_IsOK(res1)) {
20562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20563 }
20564 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20565 {
20566 PyThreadState* __tstate = wxPyBeginAllowThreads();
20567 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20568 wxPyEndAllowThreads(__tstate);
20569 if (PyErr_Occurred()) SWIG_fail;
20570 }
20571 {
20572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20573 }
20574 return resultobj;
20575 fail:
20576 return NULL;
20577 }
20578
20579
20580 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20581 PyObject *resultobj = 0;
20582 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20583 bool result;
20584 void *argp1 = 0 ;
20585 int res1 = 0 ;
20586 PyObject *swig_obj[1] ;
20587
20588 if (!args) SWIG_fail;
20589 swig_obj[0] = args;
20590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20591 if (!SWIG_IsOK(res1)) {
20592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20593 }
20594 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20595 {
20596 PyThreadState* __tstate = wxPyBeginAllowThreads();
20597 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20598 wxPyEndAllowThreads(__tstate);
20599 if (PyErr_Occurred()) SWIG_fail;
20600 }
20601 {
20602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20603 }
20604 return resultobj;
20605 fail:
20606 return NULL;
20607 }
20608
20609
20610 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20611 PyObject *resultobj = 0;
20612 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20613 bool result;
20614 void *argp1 = 0 ;
20615 int res1 = 0 ;
20616 PyObject *swig_obj[1] ;
20617
20618 if (!args) SWIG_fail;
20619 swig_obj[0] = args;
20620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20621 if (!SWIG_IsOK(res1)) {
20622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20623 }
20624 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20625 {
20626 PyThreadState* __tstate = wxPyBeginAllowThreads();
20627 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20628 wxPyEndAllowThreads(__tstate);
20629 if (PyErr_Occurred()) SWIG_fail;
20630 }
20631 {
20632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20633 }
20634 return resultobj;
20635 fail:
20636 return NULL;
20637 }
20638
20639
20640 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20641 PyObject *resultobj = 0;
20642 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20643 bool result;
20644 void *argp1 = 0 ;
20645 int res1 = 0 ;
20646 PyObject *swig_obj[1] ;
20647
20648 if (!args) SWIG_fail;
20649 swig_obj[0] = args;
20650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20651 if (!SWIG_IsOK(res1)) {
20652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20653 }
20654 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20655 {
20656 PyThreadState* __tstate = wxPyBeginAllowThreads();
20657 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20658 wxPyEndAllowThreads(__tstate);
20659 if (PyErr_Occurred()) SWIG_fail;
20660 }
20661 {
20662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20663 }
20664 return resultobj;
20665 fail:
20666 return NULL;
20667 }
20668
20669
20670 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20671 PyObject *resultobj = 0;
20672 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20673 bool result;
20674 void *argp1 = 0 ;
20675 int res1 = 0 ;
20676 PyObject *swig_obj[1] ;
20677
20678 if (!args) SWIG_fail;
20679 swig_obj[0] = args;
20680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20681 if (!SWIG_IsOK(res1)) {
20682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20683 }
20684 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20685 {
20686 PyThreadState* __tstate = wxPyBeginAllowThreads();
20687 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20688 wxPyEndAllowThreads(__tstate);
20689 if (PyErr_Occurred()) SWIG_fail;
20690 }
20691 {
20692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20693 }
20694 return resultobj;
20695 fail:
20696 return NULL;
20697 }
20698
20699
20700 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20701 PyObject *resultobj = 0;
20702 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20703 bool result;
20704 void *argp1 = 0 ;
20705 int res1 = 0 ;
20706 PyObject *swig_obj[1] ;
20707
20708 if (!args) SWIG_fail;
20709 swig_obj[0] = args;
20710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20711 if (!SWIG_IsOK(res1)) {
20712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20713 }
20714 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20715 {
20716 PyThreadState* __tstate = wxPyBeginAllowThreads();
20717 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20718 wxPyEndAllowThreads(__tstate);
20719 if (PyErr_Occurred()) SWIG_fail;
20720 }
20721 {
20722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20723 }
20724 return resultobj;
20725 fail:
20726 return NULL;
20727 }
20728
20729
20730 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20731 PyObject *resultobj = 0;
20732 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20733 bool result;
20734 void *argp1 = 0 ;
20735 int res1 = 0 ;
20736 PyObject *swig_obj[1] ;
20737
20738 if (!args) SWIG_fail;
20739 swig_obj[0] = args;
20740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20741 if (!SWIG_IsOK(res1)) {
20742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20743 }
20744 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20745 {
20746 PyThreadState* __tstate = wxPyBeginAllowThreads();
20747 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20748 wxPyEndAllowThreads(__tstate);
20749 if (PyErr_Occurred()) SWIG_fail;
20750 }
20751 {
20752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20753 }
20754 return resultobj;
20755 fail:
20756 return NULL;
20757 }
20758
20759
20760 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20761 PyObject *resultobj = 0;
20762 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20763 bool result;
20764 void *argp1 = 0 ;
20765 int res1 = 0 ;
20766 PyObject *swig_obj[1] ;
20767
20768 if (!args) SWIG_fail;
20769 swig_obj[0] = args;
20770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20771 if (!SWIG_IsOK(res1)) {
20772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20773 }
20774 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20775 {
20776 PyThreadState* __tstate = wxPyBeginAllowThreads();
20777 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20778 wxPyEndAllowThreads(__tstate);
20779 if (PyErr_Occurred()) SWIG_fail;
20780 }
20781 {
20782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20783 }
20784 return resultobj;
20785 fail:
20786 return NULL;
20787 }
20788
20789
20790 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20791 PyObject *resultobj = 0;
20792 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20793 bool result;
20794 void *argp1 = 0 ;
20795 int res1 = 0 ;
20796 PyObject *swig_obj[1] ;
20797
20798 if (!args) SWIG_fail;
20799 swig_obj[0] = args;
20800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20801 if (!SWIG_IsOK(res1)) {
20802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20803 }
20804 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20805 {
20806 PyThreadState* __tstate = wxPyBeginAllowThreads();
20807 result = (bool)(arg1)->LeftIsDown();
20808 wxPyEndAllowThreads(__tstate);
20809 if (PyErr_Occurred()) SWIG_fail;
20810 }
20811 {
20812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20813 }
20814 return resultobj;
20815 fail:
20816 return NULL;
20817 }
20818
20819
20820 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20821 PyObject *resultobj = 0;
20822 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20823 bool result;
20824 void *argp1 = 0 ;
20825 int res1 = 0 ;
20826 PyObject *swig_obj[1] ;
20827
20828 if (!args) SWIG_fail;
20829 swig_obj[0] = args;
20830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20831 if (!SWIG_IsOK(res1)) {
20832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20833 }
20834 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20835 {
20836 PyThreadState* __tstate = wxPyBeginAllowThreads();
20837 result = (bool)(arg1)->MiddleIsDown();
20838 wxPyEndAllowThreads(__tstate);
20839 if (PyErr_Occurred()) SWIG_fail;
20840 }
20841 {
20842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20843 }
20844 return resultobj;
20845 fail:
20846 return NULL;
20847 }
20848
20849
20850 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20851 PyObject *resultobj = 0;
20852 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20853 bool result;
20854 void *argp1 = 0 ;
20855 int res1 = 0 ;
20856 PyObject *swig_obj[1] ;
20857
20858 if (!args) SWIG_fail;
20859 swig_obj[0] = args;
20860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20861 if (!SWIG_IsOK(res1)) {
20862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20863 }
20864 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20865 {
20866 PyThreadState* __tstate = wxPyBeginAllowThreads();
20867 result = (bool)(arg1)->RightIsDown();
20868 wxPyEndAllowThreads(__tstate);
20869 if (PyErr_Occurred()) SWIG_fail;
20870 }
20871 {
20872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20873 }
20874 return resultobj;
20875 fail:
20876 return NULL;
20877 }
20878
20879
20880 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20881 PyObject *resultobj = 0;
20882 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20883 bool result;
20884 void *argp1 = 0 ;
20885 int res1 = 0 ;
20886 PyObject *swig_obj[1] ;
20887
20888 if (!args) SWIG_fail;
20889 swig_obj[0] = args;
20890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20891 if (!SWIG_IsOK(res1)) {
20892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20893 }
20894 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20895 {
20896 PyThreadState* __tstate = wxPyBeginAllowThreads();
20897 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20898 wxPyEndAllowThreads(__tstate);
20899 if (PyErr_Occurred()) SWIG_fail;
20900 }
20901 {
20902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20903 }
20904 return resultobj;
20905 fail:
20906 return NULL;
20907 }
20908
20909
20910 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20911 PyObject *resultobj = 0;
20912 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20913 bool result;
20914 void *argp1 = 0 ;
20915 int res1 = 0 ;
20916 PyObject *swig_obj[1] ;
20917
20918 if (!args) SWIG_fail;
20919 swig_obj[0] = args;
20920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20921 if (!SWIG_IsOK(res1)) {
20922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20923 }
20924 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20925 {
20926 PyThreadState* __tstate = wxPyBeginAllowThreads();
20927 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20928 wxPyEndAllowThreads(__tstate);
20929 if (PyErr_Occurred()) SWIG_fail;
20930 }
20931 {
20932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20933 }
20934 return resultobj;
20935 fail:
20936 return NULL;
20937 }
20938
20939
20940 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20941 PyObject *resultobj = 0;
20942 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20943 bool result;
20944 void *argp1 = 0 ;
20945 int res1 = 0 ;
20946 PyObject *swig_obj[1] ;
20947
20948 if (!args) SWIG_fail;
20949 swig_obj[0] = args;
20950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20951 if (!SWIG_IsOK(res1)) {
20952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20953 }
20954 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20955 {
20956 PyThreadState* __tstate = wxPyBeginAllowThreads();
20957 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20958 wxPyEndAllowThreads(__tstate);
20959 if (PyErr_Occurred()) SWIG_fail;
20960 }
20961 {
20962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20963 }
20964 return resultobj;
20965 fail:
20966 return NULL;
20967 }
20968
20969
20970 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20971 PyObject *resultobj = 0;
20972 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20973 bool result;
20974 void *argp1 = 0 ;
20975 int res1 = 0 ;
20976 PyObject *swig_obj[1] ;
20977
20978 if (!args) SWIG_fail;
20979 swig_obj[0] = args;
20980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20981 if (!SWIG_IsOK(res1)) {
20982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20983 }
20984 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20985 {
20986 PyThreadState* __tstate = wxPyBeginAllowThreads();
20987 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20988 wxPyEndAllowThreads(__tstate);
20989 if (PyErr_Occurred()) SWIG_fail;
20990 }
20991 {
20992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20993 }
20994 return resultobj;
20995 fail:
20996 return NULL;
20997 }
20998
20999
21000 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21001 PyObject *resultobj = 0;
21002 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21003 wxPoint result;
21004 void *argp1 = 0 ;
21005 int res1 = 0 ;
21006 PyObject *swig_obj[1] ;
21007
21008 if (!args) SWIG_fail;
21009 swig_obj[0] = args;
21010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21011 if (!SWIG_IsOK(res1)) {
21012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21013 }
21014 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21015 {
21016 PyThreadState* __tstate = wxPyBeginAllowThreads();
21017 result = (arg1)->GetPosition();
21018 wxPyEndAllowThreads(__tstate);
21019 if (PyErr_Occurred()) SWIG_fail;
21020 }
21021 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21022 return resultobj;
21023 fail:
21024 return NULL;
21025 }
21026
21027
21028 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21029 PyObject *resultobj = 0;
21030 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21031 long *arg2 = (long *) 0 ;
21032 long *arg3 = (long *) 0 ;
21033 void *argp1 = 0 ;
21034 int res1 = 0 ;
21035 long temp2 ;
21036 int res2 = SWIG_TMPOBJ ;
21037 long temp3 ;
21038 int res3 = SWIG_TMPOBJ ;
21039 PyObject *swig_obj[1] ;
21040
21041 arg2 = &temp2;
21042 arg3 = &temp3;
21043 if (!args) SWIG_fail;
21044 swig_obj[0] = args;
21045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21046 if (!SWIG_IsOK(res1)) {
21047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21048 }
21049 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21050 {
21051 PyThreadState* __tstate = wxPyBeginAllowThreads();
21052 (arg1)->GetPosition(arg2,arg3);
21053 wxPyEndAllowThreads(__tstate);
21054 if (PyErr_Occurred()) SWIG_fail;
21055 }
21056 resultobj = SWIG_Py_Void();
21057 if (SWIG_IsTmpObj(res2)) {
21058 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21059 } else {
21060 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21061 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21062 }
21063 if (SWIG_IsTmpObj(res3)) {
21064 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21065 } else {
21066 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21067 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21068 }
21069 return resultobj;
21070 fail:
21071 return NULL;
21072 }
21073
21074
21075 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21076 PyObject *resultobj = 0;
21077 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21078 wxDC *arg2 = 0 ;
21079 wxPoint result;
21080 void *argp1 = 0 ;
21081 int res1 = 0 ;
21082 void *argp2 = 0 ;
21083 int res2 = 0 ;
21084 PyObject * obj0 = 0 ;
21085 PyObject * obj1 = 0 ;
21086 char * kwnames[] = {
21087 (char *) "self",(char *) "dc", NULL
21088 };
21089
21090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21092 if (!SWIG_IsOK(res1)) {
21093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21094 }
21095 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21096 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21097 if (!SWIG_IsOK(res2)) {
21098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21099 }
21100 if (!argp2) {
21101 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21102 }
21103 arg2 = reinterpret_cast< wxDC * >(argp2);
21104 {
21105 PyThreadState* __tstate = wxPyBeginAllowThreads();
21106 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21107 wxPyEndAllowThreads(__tstate);
21108 if (PyErr_Occurred()) SWIG_fail;
21109 }
21110 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21111 return resultobj;
21112 fail:
21113 return NULL;
21114 }
21115
21116
21117 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21118 PyObject *resultobj = 0;
21119 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21120 int result;
21121 void *argp1 = 0 ;
21122 int res1 = 0 ;
21123 PyObject *swig_obj[1] ;
21124
21125 if (!args) SWIG_fail;
21126 swig_obj[0] = args;
21127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21128 if (!SWIG_IsOK(res1)) {
21129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21130 }
21131 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21132 {
21133 PyThreadState* __tstate = wxPyBeginAllowThreads();
21134 result = (int)((wxMouseEvent const *)arg1)->GetX();
21135 wxPyEndAllowThreads(__tstate);
21136 if (PyErr_Occurred()) SWIG_fail;
21137 }
21138 resultobj = SWIG_From_int(static_cast< int >(result));
21139 return resultobj;
21140 fail:
21141 return NULL;
21142 }
21143
21144
21145 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21146 PyObject *resultobj = 0;
21147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21148 int result;
21149 void *argp1 = 0 ;
21150 int res1 = 0 ;
21151 PyObject *swig_obj[1] ;
21152
21153 if (!args) SWIG_fail;
21154 swig_obj[0] = args;
21155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21156 if (!SWIG_IsOK(res1)) {
21157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21158 }
21159 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21160 {
21161 PyThreadState* __tstate = wxPyBeginAllowThreads();
21162 result = (int)((wxMouseEvent const *)arg1)->GetY();
21163 wxPyEndAllowThreads(__tstate);
21164 if (PyErr_Occurred()) SWIG_fail;
21165 }
21166 resultobj = SWIG_From_int(static_cast< int >(result));
21167 return resultobj;
21168 fail:
21169 return NULL;
21170 }
21171
21172
21173 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(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_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21186 }
21187 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21188 {
21189 PyThreadState* __tstate = wxPyBeginAllowThreads();
21190 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21191 wxPyEndAllowThreads(__tstate);
21192 if (PyErr_Occurred()) SWIG_fail;
21193 }
21194 resultobj = SWIG_From_int(static_cast< int >(result));
21195 return resultobj;
21196 fail:
21197 return NULL;
21198 }
21199
21200
21201 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21202 PyObject *resultobj = 0;
21203 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21204 int result;
21205 void *argp1 = 0 ;
21206 int res1 = 0 ;
21207 PyObject *swig_obj[1] ;
21208
21209 if (!args) SWIG_fail;
21210 swig_obj[0] = args;
21211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21212 if (!SWIG_IsOK(res1)) {
21213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21214 }
21215 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21216 {
21217 PyThreadState* __tstate = wxPyBeginAllowThreads();
21218 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21219 wxPyEndAllowThreads(__tstate);
21220 if (PyErr_Occurred()) SWIG_fail;
21221 }
21222 resultobj = SWIG_From_int(static_cast< int >(result));
21223 return resultobj;
21224 fail:
21225 return NULL;
21226 }
21227
21228
21229 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21230 PyObject *resultobj = 0;
21231 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21232 int result;
21233 void *argp1 = 0 ;
21234 int res1 = 0 ;
21235 PyObject *swig_obj[1] ;
21236
21237 if (!args) SWIG_fail;
21238 swig_obj[0] = args;
21239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21240 if (!SWIG_IsOK(res1)) {
21241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21242 }
21243 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21244 {
21245 PyThreadState* __tstate = wxPyBeginAllowThreads();
21246 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21247 wxPyEndAllowThreads(__tstate);
21248 if (PyErr_Occurred()) SWIG_fail;
21249 }
21250 resultobj = SWIG_From_int(static_cast< int >(result));
21251 return resultobj;
21252 fail:
21253 return NULL;
21254 }
21255
21256
21257 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21258 PyObject *resultobj = 0;
21259 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21260 bool result;
21261 void *argp1 = 0 ;
21262 int res1 = 0 ;
21263 PyObject *swig_obj[1] ;
21264
21265 if (!args) SWIG_fail;
21266 swig_obj[0] = args;
21267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21268 if (!SWIG_IsOK(res1)) {
21269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21270 }
21271 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21272 {
21273 PyThreadState* __tstate = wxPyBeginAllowThreads();
21274 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21275 wxPyEndAllowThreads(__tstate);
21276 if (PyErr_Occurred()) SWIG_fail;
21277 }
21278 {
21279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21280 }
21281 return resultobj;
21282 fail:
21283 return NULL;
21284 }
21285
21286
21287 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21288 PyObject *resultobj = 0;
21289 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21290 int arg2 ;
21291 void *argp1 = 0 ;
21292 int res1 = 0 ;
21293 int val2 ;
21294 int ecode2 = 0 ;
21295 PyObject *swig_obj[2] ;
21296
21297 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21299 if (!SWIG_IsOK(res1)) {
21300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21301 }
21302 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21303 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21304 if (!SWIG_IsOK(ecode2)) {
21305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21306 }
21307 arg2 = static_cast< int >(val2);
21308 if (arg1) (arg1)->m_x = arg2;
21309
21310 resultobj = SWIG_Py_Void();
21311 return resultobj;
21312 fail:
21313 return NULL;
21314 }
21315
21316
21317 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21318 PyObject *resultobj = 0;
21319 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21320 int result;
21321 void *argp1 = 0 ;
21322 int res1 = 0 ;
21323 PyObject *swig_obj[1] ;
21324
21325 if (!args) SWIG_fail;
21326 swig_obj[0] = args;
21327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21328 if (!SWIG_IsOK(res1)) {
21329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21330 }
21331 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21332 result = (int) ((arg1)->m_x);
21333 resultobj = SWIG_From_int(static_cast< int >(result));
21334 return resultobj;
21335 fail:
21336 return NULL;
21337 }
21338
21339
21340 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21341 PyObject *resultobj = 0;
21342 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21343 int arg2 ;
21344 void *argp1 = 0 ;
21345 int res1 = 0 ;
21346 int val2 ;
21347 int ecode2 = 0 ;
21348 PyObject *swig_obj[2] ;
21349
21350 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21352 if (!SWIG_IsOK(res1)) {
21353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21354 }
21355 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21356 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21357 if (!SWIG_IsOK(ecode2)) {
21358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21359 }
21360 arg2 = static_cast< int >(val2);
21361 if (arg1) (arg1)->m_y = arg2;
21362
21363 resultobj = SWIG_Py_Void();
21364 return resultobj;
21365 fail:
21366 return NULL;
21367 }
21368
21369
21370 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21371 PyObject *resultobj = 0;
21372 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21373 int result;
21374 void *argp1 = 0 ;
21375 int res1 = 0 ;
21376 PyObject *swig_obj[1] ;
21377
21378 if (!args) SWIG_fail;
21379 swig_obj[0] = args;
21380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21381 if (!SWIG_IsOK(res1)) {
21382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21383 }
21384 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21385 result = (int) ((arg1)->m_y);
21386 resultobj = SWIG_From_int(static_cast< int >(result));
21387 return resultobj;
21388 fail:
21389 return NULL;
21390 }
21391
21392
21393 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21394 PyObject *resultobj = 0;
21395 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21396 bool arg2 ;
21397 void *argp1 = 0 ;
21398 int res1 = 0 ;
21399 bool val2 ;
21400 int ecode2 = 0 ;
21401 PyObject *swig_obj[2] ;
21402
21403 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21405 if (!SWIG_IsOK(res1)) {
21406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21407 }
21408 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21409 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21410 if (!SWIG_IsOK(ecode2)) {
21411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21412 }
21413 arg2 = static_cast< bool >(val2);
21414 if (arg1) (arg1)->m_leftDown = arg2;
21415
21416 resultobj = SWIG_Py_Void();
21417 return resultobj;
21418 fail:
21419 return NULL;
21420 }
21421
21422
21423 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21424 PyObject *resultobj = 0;
21425 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21426 bool result;
21427 void *argp1 = 0 ;
21428 int res1 = 0 ;
21429 PyObject *swig_obj[1] ;
21430
21431 if (!args) SWIG_fail;
21432 swig_obj[0] = args;
21433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21434 if (!SWIG_IsOK(res1)) {
21435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21436 }
21437 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21438 result = (bool) ((arg1)->m_leftDown);
21439 {
21440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21441 }
21442 return resultobj;
21443 fail:
21444 return NULL;
21445 }
21446
21447
21448 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21449 PyObject *resultobj = 0;
21450 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21451 bool arg2 ;
21452 void *argp1 = 0 ;
21453 int res1 = 0 ;
21454 bool val2 ;
21455 int ecode2 = 0 ;
21456 PyObject *swig_obj[2] ;
21457
21458 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21460 if (!SWIG_IsOK(res1)) {
21461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21462 }
21463 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21464 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21465 if (!SWIG_IsOK(ecode2)) {
21466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21467 }
21468 arg2 = static_cast< bool >(val2);
21469 if (arg1) (arg1)->m_middleDown = arg2;
21470
21471 resultobj = SWIG_Py_Void();
21472 return resultobj;
21473 fail:
21474 return NULL;
21475 }
21476
21477
21478 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21479 PyObject *resultobj = 0;
21480 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21481 bool result;
21482 void *argp1 = 0 ;
21483 int res1 = 0 ;
21484 PyObject *swig_obj[1] ;
21485
21486 if (!args) SWIG_fail;
21487 swig_obj[0] = args;
21488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21489 if (!SWIG_IsOK(res1)) {
21490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21491 }
21492 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21493 result = (bool) ((arg1)->m_middleDown);
21494 {
21495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21496 }
21497 return resultobj;
21498 fail:
21499 return NULL;
21500 }
21501
21502
21503 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21504 PyObject *resultobj = 0;
21505 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21506 bool arg2 ;
21507 void *argp1 = 0 ;
21508 int res1 = 0 ;
21509 bool val2 ;
21510 int ecode2 = 0 ;
21511 PyObject *swig_obj[2] ;
21512
21513 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21515 if (!SWIG_IsOK(res1)) {
21516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21517 }
21518 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21519 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21520 if (!SWIG_IsOK(ecode2)) {
21521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21522 }
21523 arg2 = static_cast< bool >(val2);
21524 if (arg1) (arg1)->m_rightDown = arg2;
21525
21526 resultobj = SWIG_Py_Void();
21527 return resultobj;
21528 fail:
21529 return NULL;
21530 }
21531
21532
21533 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21534 PyObject *resultobj = 0;
21535 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21536 bool result;
21537 void *argp1 = 0 ;
21538 int res1 = 0 ;
21539 PyObject *swig_obj[1] ;
21540
21541 if (!args) SWIG_fail;
21542 swig_obj[0] = args;
21543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21544 if (!SWIG_IsOK(res1)) {
21545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21546 }
21547 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21548 result = (bool) ((arg1)->m_rightDown);
21549 {
21550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21551 }
21552 return resultobj;
21553 fail:
21554 return NULL;
21555 }
21556
21557
21558 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21559 PyObject *resultobj = 0;
21560 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21561 bool arg2 ;
21562 void *argp1 = 0 ;
21563 int res1 = 0 ;
21564 bool val2 ;
21565 int ecode2 = 0 ;
21566 PyObject *swig_obj[2] ;
21567
21568 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21570 if (!SWIG_IsOK(res1)) {
21571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21572 }
21573 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21574 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21575 if (!SWIG_IsOK(ecode2)) {
21576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21577 }
21578 arg2 = static_cast< bool >(val2);
21579 if (arg1) (arg1)->m_controlDown = arg2;
21580
21581 resultobj = SWIG_Py_Void();
21582 return resultobj;
21583 fail:
21584 return NULL;
21585 }
21586
21587
21588 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21589 PyObject *resultobj = 0;
21590 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21591 bool result;
21592 void *argp1 = 0 ;
21593 int res1 = 0 ;
21594 PyObject *swig_obj[1] ;
21595
21596 if (!args) SWIG_fail;
21597 swig_obj[0] = args;
21598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21599 if (!SWIG_IsOK(res1)) {
21600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21601 }
21602 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21603 result = (bool) ((arg1)->m_controlDown);
21604 {
21605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21606 }
21607 return resultobj;
21608 fail:
21609 return NULL;
21610 }
21611
21612
21613 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21614 PyObject *resultobj = 0;
21615 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21616 bool arg2 ;
21617 void *argp1 = 0 ;
21618 int res1 = 0 ;
21619 bool val2 ;
21620 int ecode2 = 0 ;
21621 PyObject *swig_obj[2] ;
21622
21623 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21625 if (!SWIG_IsOK(res1)) {
21626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21627 }
21628 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21629 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21630 if (!SWIG_IsOK(ecode2)) {
21631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21632 }
21633 arg2 = static_cast< bool >(val2);
21634 if (arg1) (arg1)->m_shiftDown = arg2;
21635
21636 resultobj = SWIG_Py_Void();
21637 return resultobj;
21638 fail:
21639 return NULL;
21640 }
21641
21642
21643 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21644 PyObject *resultobj = 0;
21645 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21646 bool result;
21647 void *argp1 = 0 ;
21648 int res1 = 0 ;
21649 PyObject *swig_obj[1] ;
21650
21651 if (!args) SWIG_fail;
21652 swig_obj[0] = args;
21653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21654 if (!SWIG_IsOK(res1)) {
21655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21656 }
21657 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21658 result = (bool) ((arg1)->m_shiftDown);
21659 {
21660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21661 }
21662 return resultobj;
21663 fail:
21664 return NULL;
21665 }
21666
21667
21668 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21669 PyObject *resultobj = 0;
21670 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21671 bool arg2 ;
21672 void *argp1 = 0 ;
21673 int res1 = 0 ;
21674 bool val2 ;
21675 int ecode2 = 0 ;
21676 PyObject *swig_obj[2] ;
21677
21678 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21680 if (!SWIG_IsOK(res1)) {
21681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21682 }
21683 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21684 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21685 if (!SWIG_IsOK(ecode2)) {
21686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21687 }
21688 arg2 = static_cast< bool >(val2);
21689 if (arg1) (arg1)->m_altDown = arg2;
21690
21691 resultobj = SWIG_Py_Void();
21692 return resultobj;
21693 fail:
21694 return NULL;
21695 }
21696
21697
21698 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21699 PyObject *resultobj = 0;
21700 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21701 bool result;
21702 void *argp1 = 0 ;
21703 int res1 = 0 ;
21704 PyObject *swig_obj[1] ;
21705
21706 if (!args) SWIG_fail;
21707 swig_obj[0] = args;
21708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21709 if (!SWIG_IsOK(res1)) {
21710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21711 }
21712 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21713 result = (bool) ((arg1)->m_altDown);
21714 {
21715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21716 }
21717 return resultobj;
21718 fail:
21719 return NULL;
21720 }
21721
21722
21723 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21724 PyObject *resultobj = 0;
21725 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21726 bool arg2 ;
21727 void *argp1 = 0 ;
21728 int res1 = 0 ;
21729 bool val2 ;
21730 int ecode2 = 0 ;
21731 PyObject *swig_obj[2] ;
21732
21733 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21735 if (!SWIG_IsOK(res1)) {
21736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21737 }
21738 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21739 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21740 if (!SWIG_IsOK(ecode2)) {
21741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21742 }
21743 arg2 = static_cast< bool >(val2);
21744 if (arg1) (arg1)->m_metaDown = arg2;
21745
21746 resultobj = SWIG_Py_Void();
21747 return resultobj;
21748 fail:
21749 return NULL;
21750 }
21751
21752
21753 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21754 PyObject *resultobj = 0;
21755 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21756 bool result;
21757 void *argp1 = 0 ;
21758 int res1 = 0 ;
21759 PyObject *swig_obj[1] ;
21760
21761 if (!args) SWIG_fail;
21762 swig_obj[0] = args;
21763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21764 if (!SWIG_IsOK(res1)) {
21765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21766 }
21767 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21768 result = (bool) ((arg1)->m_metaDown);
21769 {
21770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21771 }
21772 return resultobj;
21773 fail:
21774 return NULL;
21775 }
21776
21777
21778 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21779 PyObject *resultobj = 0;
21780 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21781 int arg2 ;
21782 void *argp1 = 0 ;
21783 int res1 = 0 ;
21784 int val2 ;
21785 int ecode2 = 0 ;
21786 PyObject *swig_obj[2] ;
21787
21788 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21790 if (!SWIG_IsOK(res1)) {
21791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21792 }
21793 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21794 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21795 if (!SWIG_IsOK(ecode2)) {
21796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21797 }
21798 arg2 = static_cast< int >(val2);
21799 if (arg1) (arg1)->m_wheelRotation = arg2;
21800
21801 resultobj = SWIG_Py_Void();
21802 return resultobj;
21803 fail:
21804 return NULL;
21805 }
21806
21807
21808 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21809 PyObject *resultobj = 0;
21810 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21811 int result;
21812 void *argp1 = 0 ;
21813 int res1 = 0 ;
21814 PyObject *swig_obj[1] ;
21815
21816 if (!args) SWIG_fail;
21817 swig_obj[0] = args;
21818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21819 if (!SWIG_IsOK(res1)) {
21820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21821 }
21822 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21823 result = (int) ((arg1)->m_wheelRotation);
21824 resultobj = SWIG_From_int(static_cast< int >(result));
21825 return resultobj;
21826 fail:
21827 return NULL;
21828 }
21829
21830
21831 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21832 PyObject *resultobj = 0;
21833 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21834 int arg2 ;
21835 void *argp1 = 0 ;
21836 int res1 = 0 ;
21837 int val2 ;
21838 int ecode2 = 0 ;
21839 PyObject *swig_obj[2] ;
21840
21841 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21843 if (!SWIG_IsOK(res1)) {
21844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21845 }
21846 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21847 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21848 if (!SWIG_IsOK(ecode2)) {
21849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21850 }
21851 arg2 = static_cast< int >(val2);
21852 if (arg1) (arg1)->m_wheelDelta = arg2;
21853
21854 resultobj = SWIG_Py_Void();
21855 return resultobj;
21856 fail:
21857 return NULL;
21858 }
21859
21860
21861 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21862 PyObject *resultobj = 0;
21863 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21864 int result;
21865 void *argp1 = 0 ;
21866 int res1 = 0 ;
21867 PyObject *swig_obj[1] ;
21868
21869 if (!args) SWIG_fail;
21870 swig_obj[0] = args;
21871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21872 if (!SWIG_IsOK(res1)) {
21873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21874 }
21875 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21876 result = (int) ((arg1)->m_wheelDelta);
21877 resultobj = SWIG_From_int(static_cast< int >(result));
21878 return resultobj;
21879 fail:
21880 return NULL;
21881 }
21882
21883
21884 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21885 PyObject *resultobj = 0;
21886 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21887 int arg2 ;
21888 void *argp1 = 0 ;
21889 int res1 = 0 ;
21890 int val2 ;
21891 int ecode2 = 0 ;
21892 PyObject *swig_obj[2] ;
21893
21894 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21896 if (!SWIG_IsOK(res1)) {
21897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21898 }
21899 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21900 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21901 if (!SWIG_IsOK(ecode2)) {
21902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21903 }
21904 arg2 = static_cast< int >(val2);
21905 if (arg1) (arg1)->m_linesPerAction = arg2;
21906
21907 resultobj = SWIG_Py_Void();
21908 return resultobj;
21909 fail:
21910 return NULL;
21911 }
21912
21913
21914 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21915 PyObject *resultobj = 0;
21916 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21917 int result;
21918 void *argp1 = 0 ;
21919 int res1 = 0 ;
21920 PyObject *swig_obj[1] ;
21921
21922 if (!args) SWIG_fail;
21923 swig_obj[0] = args;
21924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21925 if (!SWIG_IsOK(res1)) {
21926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21927 }
21928 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21929 result = (int) ((arg1)->m_linesPerAction);
21930 resultobj = SWIG_From_int(static_cast< int >(result));
21931 return resultobj;
21932 fail:
21933 return NULL;
21934 }
21935
21936
21937 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21938 PyObject *obj;
21939 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21940 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21941 return SWIG_Py_Void();
21942 }
21943
21944 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21945 return SWIG_Python_InitShadowInstance(args);
21946 }
21947
21948 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21949 PyObject *resultobj = 0;
21950 int arg1 = (int) 0 ;
21951 int arg2 = (int) 0 ;
21952 wxSetCursorEvent *result = 0 ;
21953 int val1 ;
21954 int ecode1 = 0 ;
21955 int val2 ;
21956 int ecode2 = 0 ;
21957 PyObject * obj0 = 0 ;
21958 PyObject * obj1 = 0 ;
21959 char * kwnames[] = {
21960 (char *) "x",(char *) "y", NULL
21961 };
21962
21963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21964 if (obj0) {
21965 ecode1 = SWIG_AsVal_int(obj0, &val1);
21966 if (!SWIG_IsOK(ecode1)) {
21967 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21968 }
21969 arg1 = static_cast< int >(val1);
21970 }
21971 if (obj1) {
21972 ecode2 = SWIG_AsVal_int(obj1, &val2);
21973 if (!SWIG_IsOK(ecode2)) {
21974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21975 }
21976 arg2 = static_cast< int >(val2);
21977 }
21978 {
21979 PyThreadState* __tstate = wxPyBeginAllowThreads();
21980 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21981 wxPyEndAllowThreads(__tstate);
21982 if (PyErr_Occurred()) SWIG_fail;
21983 }
21984 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21985 return resultobj;
21986 fail:
21987 return NULL;
21988 }
21989
21990
21991 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21992 PyObject *resultobj = 0;
21993 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21994 int result;
21995 void *argp1 = 0 ;
21996 int res1 = 0 ;
21997 PyObject *swig_obj[1] ;
21998
21999 if (!args) SWIG_fail;
22000 swig_obj[0] = args;
22001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22002 if (!SWIG_IsOK(res1)) {
22003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22004 }
22005 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22006 {
22007 PyThreadState* __tstate = wxPyBeginAllowThreads();
22008 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22009 wxPyEndAllowThreads(__tstate);
22010 if (PyErr_Occurred()) SWIG_fail;
22011 }
22012 resultobj = SWIG_From_int(static_cast< int >(result));
22013 return resultobj;
22014 fail:
22015 return NULL;
22016 }
22017
22018
22019 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22020 PyObject *resultobj = 0;
22021 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22022 int result;
22023 void *argp1 = 0 ;
22024 int res1 = 0 ;
22025 PyObject *swig_obj[1] ;
22026
22027 if (!args) SWIG_fail;
22028 swig_obj[0] = args;
22029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22030 if (!SWIG_IsOK(res1)) {
22031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22032 }
22033 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22034 {
22035 PyThreadState* __tstate = wxPyBeginAllowThreads();
22036 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22037 wxPyEndAllowThreads(__tstate);
22038 if (PyErr_Occurred()) SWIG_fail;
22039 }
22040 resultobj = SWIG_From_int(static_cast< int >(result));
22041 return resultobj;
22042 fail:
22043 return NULL;
22044 }
22045
22046
22047 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22048 PyObject *resultobj = 0;
22049 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22050 wxCursor *arg2 = 0 ;
22051 void *argp1 = 0 ;
22052 int res1 = 0 ;
22053 void *argp2 = 0 ;
22054 int res2 = 0 ;
22055 PyObject * obj0 = 0 ;
22056 PyObject * obj1 = 0 ;
22057 char * kwnames[] = {
22058 (char *) "self",(char *) "cursor", NULL
22059 };
22060
22061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22063 if (!SWIG_IsOK(res1)) {
22064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22065 }
22066 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22067 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22068 if (!SWIG_IsOK(res2)) {
22069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22070 }
22071 if (!argp2) {
22072 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22073 }
22074 arg2 = reinterpret_cast< wxCursor * >(argp2);
22075 {
22076 PyThreadState* __tstate = wxPyBeginAllowThreads();
22077 (arg1)->SetCursor((wxCursor const &)*arg2);
22078 wxPyEndAllowThreads(__tstate);
22079 if (PyErr_Occurred()) SWIG_fail;
22080 }
22081 resultobj = SWIG_Py_Void();
22082 return resultobj;
22083 fail:
22084 return NULL;
22085 }
22086
22087
22088 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22089 PyObject *resultobj = 0;
22090 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22091 wxCursor *result = 0 ;
22092 void *argp1 = 0 ;
22093 int res1 = 0 ;
22094 PyObject *swig_obj[1] ;
22095
22096 if (!args) SWIG_fail;
22097 swig_obj[0] = args;
22098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22099 if (!SWIG_IsOK(res1)) {
22100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22101 }
22102 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22103 {
22104 PyThreadState* __tstate = wxPyBeginAllowThreads();
22105 {
22106 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22107 result = (wxCursor *) &_result_ref;
22108 }
22109 wxPyEndAllowThreads(__tstate);
22110 if (PyErr_Occurred()) SWIG_fail;
22111 }
22112 {
22113 wxCursor* resultptr = new wxCursor(*result);
22114 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22115 }
22116 return resultobj;
22117 fail:
22118 return NULL;
22119 }
22120
22121
22122 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22123 PyObject *resultobj = 0;
22124 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22125 bool result;
22126 void *argp1 = 0 ;
22127 int res1 = 0 ;
22128 PyObject *swig_obj[1] ;
22129
22130 if (!args) SWIG_fail;
22131 swig_obj[0] = args;
22132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22133 if (!SWIG_IsOK(res1)) {
22134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22135 }
22136 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22137 {
22138 PyThreadState* __tstate = wxPyBeginAllowThreads();
22139 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22140 wxPyEndAllowThreads(__tstate);
22141 if (PyErr_Occurred()) SWIG_fail;
22142 }
22143 {
22144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22145 }
22146 return resultobj;
22147 fail:
22148 return NULL;
22149 }
22150
22151
22152 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22153 PyObject *obj;
22154 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22155 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22156 return SWIG_Py_Void();
22157 }
22158
22159 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22160 return SWIG_Python_InitShadowInstance(args);
22161 }
22162
22163 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22164 PyObject *resultobj = 0;
22165 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22166 wxKeyEvent *result = 0 ;
22167 int val1 ;
22168 int ecode1 = 0 ;
22169 PyObject * obj0 = 0 ;
22170 char * kwnames[] = {
22171 (char *) "eventType", NULL
22172 };
22173
22174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22175 if (obj0) {
22176 ecode1 = SWIG_AsVal_int(obj0, &val1);
22177 if (!SWIG_IsOK(ecode1)) {
22178 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22179 }
22180 arg1 = static_cast< wxEventType >(val1);
22181 }
22182 {
22183 PyThreadState* __tstate = wxPyBeginAllowThreads();
22184 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22185 wxPyEndAllowThreads(__tstate);
22186 if (PyErr_Occurred()) SWIG_fail;
22187 }
22188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22189 return resultobj;
22190 fail:
22191 return NULL;
22192 }
22193
22194
22195 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22196 PyObject *resultobj = 0;
22197 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22198 int result;
22199 void *argp1 = 0 ;
22200 int res1 = 0 ;
22201 PyObject *swig_obj[1] ;
22202
22203 if (!args) SWIG_fail;
22204 swig_obj[0] = args;
22205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22206 if (!SWIG_IsOK(res1)) {
22207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22208 }
22209 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22210 {
22211 PyThreadState* __tstate = wxPyBeginAllowThreads();
22212 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22213 wxPyEndAllowThreads(__tstate);
22214 if (PyErr_Occurred()) SWIG_fail;
22215 }
22216 resultobj = SWIG_From_int(static_cast< int >(result));
22217 return resultobj;
22218 fail:
22219 return NULL;
22220 }
22221
22222
22223 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22224 PyObject *resultobj = 0;
22225 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22226 bool result;
22227 void *argp1 = 0 ;
22228 int res1 = 0 ;
22229 PyObject *swig_obj[1] ;
22230
22231 if (!args) SWIG_fail;
22232 swig_obj[0] = args;
22233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22234 if (!SWIG_IsOK(res1)) {
22235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22236 }
22237 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22238 {
22239 PyThreadState* __tstate = wxPyBeginAllowThreads();
22240 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22241 wxPyEndAllowThreads(__tstate);
22242 if (PyErr_Occurred()) SWIG_fail;
22243 }
22244 {
22245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22246 }
22247 return resultobj;
22248 fail:
22249 return NULL;
22250 }
22251
22252
22253 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22254 PyObject *resultobj = 0;
22255 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22256 bool result;
22257 void *argp1 = 0 ;
22258 int res1 = 0 ;
22259 PyObject *swig_obj[1] ;
22260
22261 if (!args) SWIG_fail;
22262 swig_obj[0] = args;
22263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22264 if (!SWIG_IsOK(res1)) {
22265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22266 }
22267 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22268 {
22269 PyThreadState* __tstate = wxPyBeginAllowThreads();
22270 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22271 wxPyEndAllowThreads(__tstate);
22272 if (PyErr_Occurred()) SWIG_fail;
22273 }
22274 {
22275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22276 }
22277 return resultobj;
22278 fail:
22279 return NULL;
22280 }
22281
22282
22283 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22284 PyObject *resultobj = 0;
22285 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22286 bool result;
22287 void *argp1 = 0 ;
22288 int res1 = 0 ;
22289 PyObject *swig_obj[1] ;
22290
22291 if (!args) SWIG_fail;
22292 swig_obj[0] = args;
22293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22294 if (!SWIG_IsOK(res1)) {
22295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22296 }
22297 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22298 {
22299 PyThreadState* __tstate = wxPyBeginAllowThreads();
22300 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22301 wxPyEndAllowThreads(__tstate);
22302 if (PyErr_Occurred()) SWIG_fail;
22303 }
22304 {
22305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22306 }
22307 return resultobj;
22308 fail:
22309 return NULL;
22310 }
22311
22312
22313 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22314 PyObject *resultobj = 0;
22315 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22316 bool result;
22317 void *argp1 = 0 ;
22318 int res1 = 0 ;
22319 PyObject *swig_obj[1] ;
22320
22321 if (!args) SWIG_fail;
22322 swig_obj[0] = args;
22323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22324 if (!SWIG_IsOK(res1)) {
22325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22326 }
22327 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22328 {
22329 PyThreadState* __tstate = wxPyBeginAllowThreads();
22330 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22331 wxPyEndAllowThreads(__tstate);
22332 if (PyErr_Occurred()) SWIG_fail;
22333 }
22334 {
22335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22336 }
22337 return resultobj;
22338 fail:
22339 return NULL;
22340 }
22341
22342
22343 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22344 PyObject *resultobj = 0;
22345 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22346 bool result;
22347 void *argp1 = 0 ;
22348 int res1 = 0 ;
22349 PyObject *swig_obj[1] ;
22350
22351 if (!args) SWIG_fail;
22352 swig_obj[0] = args;
22353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22354 if (!SWIG_IsOK(res1)) {
22355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22356 }
22357 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22358 {
22359 PyThreadState* __tstate = wxPyBeginAllowThreads();
22360 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22361 wxPyEndAllowThreads(__tstate);
22362 if (PyErr_Occurred()) SWIG_fail;
22363 }
22364 {
22365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22366 }
22367 return resultobj;
22368 fail:
22369 return NULL;
22370 }
22371
22372
22373 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22374 PyObject *resultobj = 0;
22375 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22376 bool result;
22377 void *argp1 = 0 ;
22378 int res1 = 0 ;
22379 PyObject *swig_obj[1] ;
22380
22381 if (!args) SWIG_fail;
22382 swig_obj[0] = args;
22383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22384 if (!SWIG_IsOK(res1)) {
22385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22386 }
22387 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22388 {
22389 PyThreadState* __tstate = wxPyBeginAllowThreads();
22390 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22391 wxPyEndAllowThreads(__tstate);
22392 if (PyErr_Occurred()) SWIG_fail;
22393 }
22394 {
22395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22396 }
22397 return resultobj;
22398 fail:
22399 return NULL;
22400 }
22401
22402
22403 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22404 PyObject *resultobj = 0;
22405 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22406 int result;
22407 void *argp1 = 0 ;
22408 int res1 = 0 ;
22409 PyObject *swig_obj[1] ;
22410
22411 if (!args) SWIG_fail;
22412 swig_obj[0] = args;
22413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22414 if (!SWIG_IsOK(res1)) {
22415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22416 }
22417 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22418 {
22419 PyThreadState* __tstate = wxPyBeginAllowThreads();
22420 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22421 wxPyEndAllowThreads(__tstate);
22422 if (PyErr_Occurred()) SWIG_fail;
22423 }
22424 resultobj = SWIG_From_int(static_cast< int >(result));
22425 return resultobj;
22426 fail:
22427 return NULL;
22428 }
22429
22430
22431 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(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_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22444 }
22445 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22446 {
22447 PyThreadState* __tstate = wxPyBeginAllowThreads();
22448 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
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_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22460 PyObject *resultobj = 0;
22461 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22462 int arg2 ;
22463 void *argp1 = 0 ;
22464 int res1 = 0 ;
22465 int val2 ;
22466 int ecode2 = 0 ;
22467 PyObject * obj0 = 0 ;
22468 PyObject * obj1 = 0 ;
22469 char * kwnames[] = {
22470 (char *) "self",(char *) "uniChar", NULL
22471 };
22472
22473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22475 if (!SWIG_IsOK(res1)) {
22476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22477 }
22478 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22479 ecode2 = SWIG_AsVal_int(obj1, &val2);
22480 if (!SWIG_IsOK(ecode2)) {
22481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22482 }
22483 arg2 = static_cast< int >(val2);
22484 {
22485 PyThreadState* __tstate = wxPyBeginAllowThreads();
22486 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22487 wxPyEndAllowThreads(__tstate);
22488 if (PyErr_Occurred()) SWIG_fail;
22489 }
22490 resultobj = SWIG_Py_Void();
22491 return resultobj;
22492 fail:
22493 return NULL;
22494 }
22495
22496
22497 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22498 PyObject *resultobj = 0;
22499 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22500 unsigned int result;
22501 void *argp1 = 0 ;
22502 int res1 = 0 ;
22503 PyObject *swig_obj[1] ;
22504
22505 if (!args) SWIG_fail;
22506 swig_obj[0] = args;
22507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22508 if (!SWIG_IsOK(res1)) {
22509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22510 }
22511 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22512 {
22513 PyThreadState* __tstate = wxPyBeginAllowThreads();
22514 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22515 wxPyEndAllowThreads(__tstate);
22516 if (PyErr_Occurred()) SWIG_fail;
22517 }
22518 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22519 return resultobj;
22520 fail:
22521 return NULL;
22522 }
22523
22524
22525 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22526 PyObject *resultobj = 0;
22527 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22528 unsigned int result;
22529 void *argp1 = 0 ;
22530 int res1 = 0 ;
22531 PyObject *swig_obj[1] ;
22532
22533 if (!args) SWIG_fail;
22534 swig_obj[0] = args;
22535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22536 if (!SWIG_IsOK(res1)) {
22537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22538 }
22539 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22540 {
22541 PyThreadState* __tstate = wxPyBeginAllowThreads();
22542 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22543 wxPyEndAllowThreads(__tstate);
22544 if (PyErr_Occurred()) SWIG_fail;
22545 }
22546 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22547 return resultobj;
22548 fail:
22549 return NULL;
22550 }
22551
22552
22553 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22554 PyObject *resultobj = 0;
22555 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22556 wxPoint result;
22557 void *argp1 = 0 ;
22558 int res1 = 0 ;
22559 PyObject *swig_obj[1] ;
22560
22561 if (!args) SWIG_fail;
22562 swig_obj[0] = args;
22563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22564 if (!SWIG_IsOK(res1)) {
22565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22566 }
22567 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22568 {
22569 PyThreadState* __tstate = wxPyBeginAllowThreads();
22570 result = (arg1)->GetPosition();
22571 wxPyEndAllowThreads(__tstate);
22572 if (PyErr_Occurred()) SWIG_fail;
22573 }
22574 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22575 return resultobj;
22576 fail:
22577 return NULL;
22578 }
22579
22580
22581 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22582 PyObject *resultobj = 0;
22583 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22584 long *arg2 = (long *) 0 ;
22585 long *arg3 = (long *) 0 ;
22586 void *argp1 = 0 ;
22587 int res1 = 0 ;
22588 long temp2 ;
22589 int res2 = SWIG_TMPOBJ ;
22590 long temp3 ;
22591 int res3 = SWIG_TMPOBJ ;
22592 PyObject *swig_obj[1] ;
22593
22594 arg2 = &temp2;
22595 arg3 = &temp3;
22596 if (!args) SWIG_fail;
22597 swig_obj[0] = args;
22598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22599 if (!SWIG_IsOK(res1)) {
22600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22601 }
22602 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22603 {
22604 PyThreadState* __tstate = wxPyBeginAllowThreads();
22605 (arg1)->GetPosition(arg2,arg3);
22606 wxPyEndAllowThreads(__tstate);
22607 if (PyErr_Occurred()) SWIG_fail;
22608 }
22609 resultobj = SWIG_Py_Void();
22610 if (SWIG_IsTmpObj(res2)) {
22611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22612 } else {
22613 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22615 }
22616 if (SWIG_IsTmpObj(res3)) {
22617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22618 } else {
22619 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22621 }
22622 return resultobj;
22623 fail:
22624 return NULL;
22625 }
22626
22627
22628 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22629 PyObject *resultobj = 0;
22630 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22631 int result;
22632 void *argp1 = 0 ;
22633 int res1 = 0 ;
22634 PyObject *swig_obj[1] ;
22635
22636 if (!args) SWIG_fail;
22637 swig_obj[0] = args;
22638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22639 if (!SWIG_IsOK(res1)) {
22640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22641 }
22642 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22643 {
22644 PyThreadState* __tstate = wxPyBeginAllowThreads();
22645 result = (int)((wxKeyEvent const *)arg1)->GetX();
22646 wxPyEndAllowThreads(__tstate);
22647 if (PyErr_Occurred()) SWIG_fail;
22648 }
22649 resultobj = SWIG_From_int(static_cast< int >(result));
22650 return resultobj;
22651 fail:
22652 return NULL;
22653 }
22654
22655
22656 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22657 PyObject *resultobj = 0;
22658 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22659 int result;
22660 void *argp1 = 0 ;
22661 int res1 = 0 ;
22662 PyObject *swig_obj[1] ;
22663
22664 if (!args) SWIG_fail;
22665 swig_obj[0] = args;
22666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22667 if (!SWIG_IsOK(res1)) {
22668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22669 }
22670 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22671 {
22672 PyThreadState* __tstate = wxPyBeginAllowThreads();
22673 result = (int)((wxKeyEvent const *)arg1)->GetY();
22674 wxPyEndAllowThreads(__tstate);
22675 if (PyErr_Occurred()) SWIG_fail;
22676 }
22677 resultobj = SWIG_From_int(static_cast< int >(result));
22678 return resultobj;
22679 fail:
22680 return NULL;
22681 }
22682
22683
22684 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22685 PyObject *resultobj = 0;
22686 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22687 int arg2 ;
22688 void *argp1 = 0 ;
22689 int res1 = 0 ;
22690 int val2 ;
22691 int ecode2 = 0 ;
22692 PyObject *swig_obj[2] ;
22693
22694 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22696 if (!SWIG_IsOK(res1)) {
22697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22698 }
22699 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22700 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22701 if (!SWIG_IsOK(ecode2)) {
22702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22703 }
22704 arg2 = static_cast< int >(val2);
22705 if (arg1) (arg1)->m_x = arg2;
22706
22707 resultobj = SWIG_Py_Void();
22708 return resultobj;
22709 fail:
22710 return NULL;
22711 }
22712
22713
22714 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22715 PyObject *resultobj = 0;
22716 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22717 int result;
22718 void *argp1 = 0 ;
22719 int res1 = 0 ;
22720 PyObject *swig_obj[1] ;
22721
22722 if (!args) SWIG_fail;
22723 swig_obj[0] = args;
22724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22725 if (!SWIG_IsOK(res1)) {
22726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22727 }
22728 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22729 result = (int) ((arg1)->m_x);
22730 resultobj = SWIG_From_int(static_cast< int >(result));
22731 return resultobj;
22732 fail:
22733 return NULL;
22734 }
22735
22736
22737 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22738 PyObject *resultobj = 0;
22739 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22740 int arg2 ;
22741 void *argp1 = 0 ;
22742 int res1 = 0 ;
22743 int val2 ;
22744 int ecode2 = 0 ;
22745 PyObject *swig_obj[2] ;
22746
22747 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22749 if (!SWIG_IsOK(res1)) {
22750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22751 }
22752 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22753 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22754 if (!SWIG_IsOK(ecode2)) {
22755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22756 }
22757 arg2 = static_cast< int >(val2);
22758 if (arg1) (arg1)->m_y = arg2;
22759
22760 resultobj = SWIG_Py_Void();
22761 return resultobj;
22762 fail:
22763 return NULL;
22764 }
22765
22766
22767 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22768 PyObject *resultobj = 0;
22769 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22770 int result;
22771 void *argp1 = 0 ;
22772 int res1 = 0 ;
22773 PyObject *swig_obj[1] ;
22774
22775 if (!args) SWIG_fail;
22776 swig_obj[0] = args;
22777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22778 if (!SWIG_IsOK(res1)) {
22779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22780 }
22781 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22782 result = (int) ((arg1)->m_y);
22783 resultobj = SWIG_From_int(static_cast< int >(result));
22784 return resultobj;
22785 fail:
22786 return NULL;
22787 }
22788
22789
22790 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22791 PyObject *resultobj = 0;
22792 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22793 long arg2 ;
22794 void *argp1 = 0 ;
22795 int res1 = 0 ;
22796 long val2 ;
22797 int ecode2 = 0 ;
22798 PyObject *swig_obj[2] ;
22799
22800 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22802 if (!SWIG_IsOK(res1)) {
22803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22804 }
22805 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22806 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22807 if (!SWIG_IsOK(ecode2)) {
22808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22809 }
22810 arg2 = static_cast< long >(val2);
22811 if (arg1) (arg1)->m_keyCode = arg2;
22812
22813 resultobj = SWIG_Py_Void();
22814 return resultobj;
22815 fail:
22816 return NULL;
22817 }
22818
22819
22820 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22821 PyObject *resultobj = 0;
22822 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22823 long result;
22824 void *argp1 = 0 ;
22825 int res1 = 0 ;
22826 PyObject *swig_obj[1] ;
22827
22828 if (!args) SWIG_fail;
22829 swig_obj[0] = args;
22830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22831 if (!SWIG_IsOK(res1)) {
22832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22833 }
22834 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22835 result = (long) ((arg1)->m_keyCode);
22836 resultobj = SWIG_From_long(static_cast< long >(result));
22837 return resultobj;
22838 fail:
22839 return NULL;
22840 }
22841
22842
22843 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22844 PyObject *resultobj = 0;
22845 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22846 bool arg2 ;
22847 void *argp1 = 0 ;
22848 int res1 = 0 ;
22849 bool val2 ;
22850 int ecode2 = 0 ;
22851 PyObject *swig_obj[2] ;
22852
22853 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22855 if (!SWIG_IsOK(res1)) {
22856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22857 }
22858 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22859 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22860 if (!SWIG_IsOK(ecode2)) {
22861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22862 }
22863 arg2 = static_cast< bool >(val2);
22864 if (arg1) (arg1)->m_controlDown = arg2;
22865
22866 resultobj = SWIG_Py_Void();
22867 return resultobj;
22868 fail:
22869 return NULL;
22870 }
22871
22872
22873 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22874 PyObject *resultobj = 0;
22875 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22876 bool result;
22877 void *argp1 = 0 ;
22878 int res1 = 0 ;
22879 PyObject *swig_obj[1] ;
22880
22881 if (!args) SWIG_fail;
22882 swig_obj[0] = args;
22883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22884 if (!SWIG_IsOK(res1)) {
22885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22886 }
22887 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22888 result = (bool) ((arg1)->m_controlDown);
22889 {
22890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22891 }
22892 return resultobj;
22893 fail:
22894 return NULL;
22895 }
22896
22897
22898 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22899 PyObject *resultobj = 0;
22900 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22901 bool arg2 ;
22902 void *argp1 = 0 ;
22903 int res1 = 0 ;
22904 bool val2 ;
22905 int ecode2 = 0 ;
22906 PyObject *swig_obj[2] ;
22907
22908 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22910 if (!SWIG_IsOK(res1)) {
22911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22912 }
22913 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22914 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22915 if (!SWIG_IsOK(ecode2)) {
22916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22917 }
22918 arg2 = static_cast< bool >(val2);
22919 if (arg1) (arg1)->m_shiftDown = arg2;
22920
22921 resultobj = SWIG_Py_Void();
22922 return resultobj;
22923 fail:
22924 return NULL;
22925 }
22926
22927
22928 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22929 PyObject *resultobj = 0;
22930 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22931 bool result;
22932 void *argp1 = 0 ;
22933 int res1 = 0 ;
22934 PyObject *swig_obj[1] ;
22935
22936 if (!args) SWIG_fail;
22937 swig_obj[0] = args;
22938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22939 if (!SWIG_IsOK(res1)) {
22940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22941 }
22942 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22943 result = (bool) ((arg1)->m_shiftDown);
22944 {
22945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22946 }
22947 return resultobj;
22948 fail:
22949 return NULL;
22950 }
22951
22952
22953 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22954 PyObject *resultobj = 0;
22955 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22956 bool arg2 ;
22957 void *argp1 = 0 ;
22958 int res1 = 0 ;
22959 bool val2 ;
22960 int ecode2 = 0 ;
22961 PyObject *swig_obj[2] ;
22962
22963 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22965 if (!SWIG_IsOK(res1)) {
22966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22967 }
22968 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22969 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22970 if (!SWIG_IsOK(ecode2)) {
22971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22972 }
22973 arg2 = static_cast< bool >(val2);
22974 if (arg1) (arg1)->m_altDown = arg2;
22975
22976 resultobj = SWIG_Py_Void();
22977 return resultobj;
22978 fail:
22979 return NULL;
22980 }
22981
22982
22983 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22984 PyObject *resultobj = 0;
22985 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22986 bool result;
22987 void *argp1 = 0 ;
22988 int res1 = 0 ;
22989 PyObject *swig_obj[1] ;
22990
22991 if (!args) SWIG_fail;
22992 swig_obj[0] = args;
22993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22994 if (!SWIG_IsOK(res1)) {
22995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22996 }
22997 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22998 result = (bool) ((arg1)->m_altDown);
22999 {
23000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23001 }
23002 return resultobj;
23003 fail:
23004 return NULL;
23005 }
23006
23007
23008 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23009 PyObject *resultobj = 0;
23010 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23011 bool arg2 ;
23012 void *argp1 = 0 ;
23013 int res1 = 0 ;
23014 bool val2 ;
23015 int ecode2 = 0 ;
23016 PyObject *swig_obj[2] ;
23017
23018 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23020 if (!SWIG_IsOK(res1)) {
23021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23022 }
23023 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23024 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23025 if (!SWIG_IsOK(ecode2)) {
23026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23027 }
23028 arg2 = static_cast< bool >(val2);
23029 if (arg1) (arg1)->m_metaDown = arg2;
23030
23031 resultobj = SWIG_Py_Void();
23032 return resultobj;
23033 fail:
23034 return NULL;
23035 }
23036
23037
23038 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23039 PyObject *resultobj = 0;
23040 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23041 bool result;
23042 void *argp1 = 0 ;
23043 int res1 = 0 ;
23044 PyObject *swig_obj[1] ;
23045
23046 if (!args) SWIG_fail;
23047 swig_obj[0] = args;
23048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23049 if (!SWIG_IsOK(res1)) {
23050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23051 }
23052 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23053 result = (bool) ((arg1)->m_metaDown);
23054 {
23055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23056 }
23057 return resultobj;
23058 fail:
23059 return NULL;
23060 }
23061
23062
23063 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23064 PyObject *resultobj = 0;
23065 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23066 bool arg2 ;
23067 void *argp1 = 0 ;
23068 int res1 = 0 ;
23069 bool val2 ;
23070 int ecode2 = 0 ;
23071 PyObject *swig_obj[2] ;
23072
23073 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23075 if (!SWIG_IsOK(res1)) {
23076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23077 }
23078 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23079 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23080 if (!SWIG_IsOK(ecode2)) {
23081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23082 }
23083 arg2 = static_cast< bool >(val2);
23084 if (arg1) (arg1)->m_scanCode = arg2;
23085
23086 resultobj = SWIG_Py_Void();
23087 return resultobj;
23088 fail:
23089 return NULL;
23090 }
23091
23092
23093 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23094 PyObject *resultobj = 0;
23095 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23096 bool result;
23097 void *argp1 = 0 ;
23098 int res1 = 0 ;
23099 PyObject *swig_obj[1] ;
23100
23101 if (!args) SWIG_fail;
23102 swig_obj[0] = args;
23103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23104 if (!SWIG_IsOK(res1)) {
23105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23106 }
23107 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23108 result = (bool) ((arg1)->m_scanCode);
23109 {
23110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23111 }
23112 return resultobj;
23113 fail:
23114 return NULL;
23115 }
23116
23117
23118 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23119 PyObject *resultobj = 0;
23120 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23121 unsigned int arg2 ;
23122 void *argp1 = 0 ;
23123 int res1 = 0 ;
23124 unsigned int val2 ;
23125 int ecode2 = 0 ;
23126 PyObject *swig_obj[2] ;
23127
23128 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23130 if (!SWIG_IsOK(res1)) {
23131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23132 }
23133 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23134 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23135 if (!SWIG_IsOK(ecode2)) {
23136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23137 }
23138 arg2 = static_cast< unsigned int >(val2);
23139 if (arg1) (arg1)->m_rawCode = arg2;
23140
23141 resultobj = SWIG_Py_Void();
23142 return resultobj;
23143 fail:
23144 return NULL;
23145 }
23146
23147
23148 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23149 PyObject *resultobj = 0;
23150 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23151 unsigned int result;
23152 void *argp1 = 0 ;
23153 int res1 = 0 ;
23154 PyObject *swig_obj[1] ;
23155
23156 if (!args) SWIG_fail;
23157 swig_obj[0] = args;
23158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23159 if (!SWIG_IsOK(res1)) {
23160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23161 }
23162 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23163 result = (unsigned int) ((arg1)->m_rawCode);
23164 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23165 return resultobj;
23166 fail:
23167 return NULL;
23168 }
23169
23170
23171 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23172 PyObject *resultobj = 0;
23173 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23174 unsigned int arg2 ;
23175 void *argp1 = 0 ;
23176 int res1 = 0 ;
23177 unsigned int val2 ;
23178 int ecode2 = 0 ;
23179 PyObject *swig_obj[2] ;
23180
23181 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23183 if (!SWIG_IsOK(res1)) {
23184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23185 }
23186 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23187 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23188 if (!SWIG_IsOK(ecode2)) {
23189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23190 }
23191 arg2 = static_cast< unsigned int >(val2);
23192 if (arg1) (arg1)->m_rawFlags = arg2;
23193
23194 resultobj = SWIG_Py_Void();
23195 return resultobj;
23196 fail:
23197 return NULL;
23198 }
23199
23200
23201 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23202 PyObject *resultobj = 0;
23203 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23204 unsigned int result;
23205 void *argp1 = 0 ;
23206 int res1 = 0 ;
23207 PyObject *swig_obj[1] ;
23208
23209 if (!args) SWIG_fail;
23210 swig_obj[0] = args;
23211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23212 if (!SWIG_IsOK(res1)) {
23213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23214 }
23215 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23216 result = (unsigned int) ((arg1)->m_rawFlags);
23217 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23218 return resultobj;
23219 fail:
23220 return NULL;
23221 }
23222
23223
23224 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23225 PyObject *obj;
23226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23227 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23228 return SWIG_Py_Void();
23229 }
23230
23231 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23232 return SWIG_Python_InitShadowInstance(args);
23233 }
23234
23235 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23236 PyObject *resultobj = 0;
23237 wxSize const &arg1_defvalue = wxDefaultSize ;
23238 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23239 int arg2 = (int) 0 ;
23240 wxSizeEvent *result = 0 ;
23241 wxSize temp1 ;
23242 int val2 ;
23243 int ecode2 = 0 ;
23244 PyObject * obj0 = 0 ;
23245 PyObject * obj1 = 0 ;
23246 char * kwnames[] = {
23247 (char *) "sz",(char *) "winid", NULL
23248 };
23249
23250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23251 if (obj0) {
23252 {
23253 arg1 = &temp1;
23254 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23255 }
23256 }
23257 if (obj1) {
23258 ecode2 = SWIG_AsVal_int(obj1, &val2);
23259 if (!SWIG_IsOK(ecode2)) {
23260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23261 }
23262 arg2 = static_cast< int >(val2);
23263 }
23264 {
23265 PyThreadState* __tstate = wxPyBeginAllowThreads();
23266 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23267 wxPyEndAllowThreads(__tstate);
23268 if (PyErr_Occurred()) SWIG_fail;
23269 }
23270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23271 return resultobj;
23272 fail:
23273 return NULL;
23274 }
23275
23276
23277 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23278 PyObject *resultobj = 0;
23279 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23280 wxSize result;
23281 void *argp1 = 0 ;
23282 int res1 = 0 ;
23283 PyObject *swig_obj[1] ;
23284
23285 if (!args) SWIG_fail;
23286 swig_obj[0] = args;
23287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23288 if (!SWIG_IsOK(res1)) {
23289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23290 }
23291 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23292 {
23293 PyThreadState* __tstate = wxPyBeginAllowThreads();
23294 result = ((wxSizeEvent const *)arg1)->GetSize();
23295 wxPyEndAllowThreads(__tstate);
23296 if (PyErr_Occurred()) SWIG_fail;
23297 }
23298 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23299 return resultobj;
23300 fail:
23301 return NULL;
23302 }
23303
23304
23305 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23306 PyObject *resultobj = 0;
23307 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23308 wxRect result;
23309 void *argp1 = 0 ;
23310 int res1 = 0 ;
23311 PyObject *swig_obj[1] ;
23312
23313 if (!args) SWIG_fail;
23314 swig_obj[0] = args;
23315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23316 if (!SWIG_IsOK(res1)) {
23317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23318 }
23319 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23320 {
23321 PyThreadState* __tstate = wxPyBeginAllowThreads();
23322 result = ((wxSizeEvent const *)arg1)->GetRect();
23323 wxPyEndAllowThreads(__tstate);
23324 if (PyErr_Occurred()) SWIG_fail;
23325 }
23326 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23327 return resultobj;
23328 fail:
23329 return NULL;
23330 }
23331
23332
23333 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23334 PyObject *resultobj = 0;
23335 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23336 wxRect arg2 ;
23337 void *argp1 = 0 ;
23338 int res1 = 0 ;
23339 void *argp2 ;
23340 int res2 = 0 ;
23341 PyObject * obj0 = 0 ;
23342 PyObject * obj1 = 0 ;
23343 char * kwnames[] = {
23344 (char *) "self",(char *) "rect", NULL
23345 };
23346
23347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23349 if (!SWIG_IsOK(res1)) {
23350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23351 }
23352 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23353 {
23354 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23355 if (!SWIG_IsOK(res2)) {
23356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23357 }
23358 if (!argp2) {
23359 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23360 } else {
23361 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23362 arg2 = *temp;
23363 if (SWIG_IsNewObj(res2)) delete temp;
23364 }
23365 }
23366 {
23367 PyThreadState* __tstate = wxPyBeginAllowThreads();
23368 (arg1)->SetRect(arg2);
23369 wxPyEndAllowThreads(__tstate);
23370 if (PyErr_Occurred()) SWIG_fail;
23371 }
23372 resultobj = SWIG_Py_Void();
23373 return resultobj;
23374 fail:
23375 return NULL;
23376 }
23377
23378
23379 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23380 PyObject *resultobj = 0;
23381 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23382 wxSize arg2 ;
23383 void *argp1 = 0 ;
23384 int res1 = 0 ;
23385 void *argp2 ;
23386 int res2 = 0 ;
23387 PyObject * obj0 = 0 ;
23388 PyObject * obj1 = 0 ;
23389 char * kwnames[] = {
23390 (char *) "self",(char *) "size", NULL
23391 };
23392
23393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23395 if (!SWIG_IsOK(res1)) {
23396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23397 }
23398 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23399 {
23400 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23401 if (!SWIG_IsOK(res2)) {
23402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23403 }
23404 if (!argp2) {
23405 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23406 } else {
23407 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23408 arg2 = *temp;
23409 if (SWIG_IsNewObj(res2)) delete temp;
23410 }
23411 }
23412 {
23413 PyThreadState* __tstate = wxPyBeginAllowThreads();
23414 wxSizeEvent_SetSize(arg1,arg2);
23415 wxPyEndAllowThreads(__tstate);
23416 if (PyErr_Occurred()) SWIG_fail;
23417 }
23418 resultobj = SWIG_Py_Void();
23419 return resultobj;
23420 fail:
23421 return NULL;
23422 }
23423
23424
23425 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23426 PyObject *resultobj = 0;
23427 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23428 wxSize *arg2 = (wxSize *) 0 ;
23429 void *argp1 = 0 ;
23430 int res1 = 0 ;
23431 void *argp2 = 0 ;
23432 int res2 = 0 ;
23433 PyObject *swig_obj[2] ;
23434
23435 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23437 if (!SWIG_IsOK(res1)) {
23438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23439 }
23440 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23441 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23442 if (!SWIG_IsOK(res2)) {
23443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23444 }
23445 arg2 = reinterpret_cast< wxSize * >(argp2);
23446 if (arg1) (arg1)->m_size = *arg2;
23447
23448 resultobj = SWIG_Py_Void();
23449 return resultobj;
23450 fail:
23451 return NULL;
23452 }
23453
23454
23455 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23456 PyObject *resultobj = 0;
23457 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23458 wxSize *result = 0 ;
23459 void *argp1 = 0 ;
23460 int res1 = 0 ;
23461 PyObject *swig_obj[1] ;
23462
23463 if (!args) SWIG_fail;
23464 swig_obj[0] = args;
23465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23466 if (!SWIG_IsOK(res1)) {
23467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23468 }
23469 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23470 result = (wxSize *)& ((arg1)->m_size);
23471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23472 return resultobj;
23473 fail:
23474 return NULL;
23475 }
23476
23477
23478 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23479 PyObject *resultobj = 0;
23480 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23481 wxRect *arg2 = (wxRect *) 0 ;
23482 void *argp1 = 0 ;
23483 int res1 = 0 ;
23484 void *argp2 = 0 ;
23485 int res2 = 0 ;
23486 PyObject *swig_obj[2] ;
23487
23488 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23490 if (!SWIG_IsOK(res1)) {
23491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23492 }
23493 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23494 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23495 if (!SWIG_IsOK(res2)) {
23496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23497 }
23498 arg2 = reinterpret_cast< wxRect * >(argp2);
23499 if (arg1) (arg1)->m_rect = *arg2;
23500
23501 resultobj = SWIG_Py_Void();
23502 return resultobj;
23503 fail:
23504 return NULL;
23505 }
23506
23507
23508 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23509 PyObject *resultobj = 0;
23510 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23511 wxRect *result = 0 ;
23512 void *argp1 = 0 ;
23513 int res1 = 0 ;
23514 PyObject *swig_obj[1] ;
23515
23516 if (!args) SWIG_fail;
23517 swig_obj[0] = args;
23518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23519 if (!SWIG_IsOK(res1)) {
23520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23521 }
23522 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23523 result = (wxRect *)& ((arg1)->m_rect);
23524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23525 return resultobj;
23526 fail:
23527 return NULL;
23528 }
23529
23530
23531 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23532 PyObject *obj;
23533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23534 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23535 return SWIG_Py_Void();
23536 }
23537
23538 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23539 return SWIG_Python_InitShadowInstance(args);
23540 }
23541
23542 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23543 PyObject *resultobj = 0;
23544 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23545 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23546 int arg2 = (int) 0 ;
23547 wxMoveEvent *result = 0 ;
23548 wxPoint temp1 ;
23549 int val2 ;
23550 int ecode2 = 0 ;
23551 PyObject * obj0 = 0 ;
23552 PyObject * obj1 = 0 ;
23553 char * kwnames[] = {
23554 (char *) "pos",(char *) "winid", NULL
23555 };
23556
23557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23558 if (obj0) {
23559 {
23560 arg1 = &temp1;
23561 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23562 }
23563 }
23564 if (obj1) {
23565 ecode2 = SWIG_AsVal_int(obj1, &val2);
23566 if (!SWIG_IsOK(ecode2)) {
23567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23568 }
23569 arg2 = static_cast< int >(val2);
23570 }
23571 {
23572 PyThreadState* __tstate = wxPyBeginAllowThreads();
23573 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23574 wxPyEndAllowThreads(__tstate);
23575 if (PyErr_Occurred()) SWIG_fail;
23576 }
23577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23578 return resultobj;
23579 fail:
23580 return NULL;
23581 }
23582
23583
23584 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23585 PyObject *resultobj = 0;
23586 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23587 wxPoint result;
23588 void *argp1 = 0 ;
23589 int res1 = 0 ;
23590 PyObject *swig_obj[1] ;
23591
23592 if (!args) SWIG_fail;
23593 swig_obj[0] = args;
23594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23595 if (!SWIG_IsOK(res1)) {
23596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23597 }
23598 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23599 {
23600 PyThreadState* __tstate = wxPyBeginAllowThreads();
23601 result = ((wxMoveEvent const *)arg1)->GetPosition();
23602 wxPyEndAllowThreads(__tstate);
23603 if (PyErr_Occurred()) SWIG_fail;
23604 }
23605 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23606 return resultobj;
23607 fail:
23608 return NULL;
23609 }
23610
23611
23612 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23613 PyObject *resultobj = 0;
23614 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23615 wxRect result;
23616 void *argp1 = 0 ;
23617 int res1 = 0 ;
23618 PyObject *swig_obj[1] ;
23619
23620 if (!args) SWIG_fail;
23621 swig_obj[0] = args;
23622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23623 if (!SWIG_IsOK(res1)) {
23624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23625 }
23626 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23627 {
23628 PyThreadState* __tstate = wxPyBeginAllowThreads();
23629 result = ((wxMoveEvent const *)arg1)->GetRect();
23630 wxPyEndAllowThreads(__tstate);
23631 if (PyErr_Occurred()) SWIG_fail;
23632 }
23633 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23634 return resultobj;
23635 fail:
23636 return NULL;
23637 }
23638
23639
23640 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23641 PyObject *resultobj = 0;
23642 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23643 wxRect *arg2 = 0 ;
23644 void *argp1 = 0 ;
23645 int res1 = 0 ;
23646 wxRect temp2 ;
23647 PyObject * obj0 = 0 ;
23648 PyObject * obj1 = 0 ;
23649 char * kwnames[] = {
23650 (char *) "self",(char *) "rect", NULL
23651 };
23652
23653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23655 if (!SWIG_IsOK(res1)) {
23656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23657 }
23658 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23659 {
23660 arg2 = &temp2;
23661 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23662 }
23663 {
23664 PyThreadState* __tstate = wxPyBeginAllowThreads();
23665 (arg1)->SetRect((wxRect const &)*arg2);
23666 wxPyEndAllowThreads(__tstate);
23667 if (PyErr_Occurred()) SWIG_fail;
23668 }
23669 resultobj = SWIG_Py_Void();
23670 return resultobj;
23671 fail:
23672 return NULL;
23673 }
23674
23675
23676 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23677 PyObject *resultobj = 0;
23678 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23679 wxPoint *arg2 = 0 ;
23680 void *argp1 = 0 ;
23681 int res1 = 0 ;
23682 wxPoint temp2 ;
23683 PyObject * obj0 = 0 ;
23684 PyObject * obj1 = 0 ;
23685 char * kwnames[] = {
23686 (char *) "self",(char *) "pos", NULL
23687 };
23688
23689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23691 if (!SWIG_IsOK(res1)) {
23692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23693 }
23694 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23695 {
23696 arg2 = &temp2;
23697 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23698 }
23699 {
23700 PyThreadState* __tstate = wxPyBeginAllowThreads();
23701 (arg1)->SetPosition((wxPoint const &)*arg2);
23702 wxPyEndAllowThreads(__tstate);
23703 if (PyErr_Occurred()) SWIG_fail;
23704 }
23705 resultobj = SWIG_Py_Void();
23706 return resultobj;
23707 fail:
23708 return NULL;
23709 }
23710
23711
23712 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23713 PyObject *obj;
23714 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23715 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23716 return SWIG_Py_Void();
23717 }
23718
23719 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23720 return SWIG_Python_InitShadowInstance(args);
23721 }
23722
23723 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23724 PyObject *resultobj = 0;
23725 int arg1 = (int) 0 ;
23726 wxPaintEvent *result = 0 ;
23727 int val1 ;
23728 int ecode1 = 0 ;
23729 PyObject * obj0 = 0 ;
23730 char * kwnames[] = {
23731 (char *) "Id", NULL
23732 };
23733
23734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23735 if (obj0) {
23736 ecode1 = SWIG_AsVal_int(obj0, &val1);
23737 if (!SWIG_IsOK(ecode1)) {
23738 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23739 }
23740 arg1 = static_cast< int >(val1);
23741 }
23742 {
23743 PyThreadState* __tstate = wxPyBeginAllowThreads();
23744 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23745 wxPyEndAllowThreads(__tstate);
23746 if (PyErr_Occurred()) SWIG_fail;
23747 }
23748 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23749 return resultobj;
23750 fail:
23751 return NULL;
23752 }
23753
23754
23755 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23756 PyObject *obj;
23757 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23758 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23759 return SWIG_Py_Void();
23760 }
23761
23762 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23763 return SWIG_Python_InitShadowInstance(args);
23764 }
23765
23766 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23767 PyObject *resultobj = 0;
23768 int arg1 = (int) 0 ;
23769 wxNcPaintEvent *result = 0 ;
23770 int val1 ;
23771 int ecode1 = 0 ;
23772 PyObject * obj0 = 0 ;
23773 char * kwnames[] = {
23774 (char *) "winid", NULL
23775 };
23776
23777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23778 if (obj0) {
23779 ecode1 = SWIG_AsVal_int(obj0, &val1);
23780 if (!SWIG_IsOK(ecode1)) {
23781 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23782 }
23783 arg1 = static_cast< int >(val1);
23784 }
23785 {
23786 PyThreadState* __tstate = wxPyBeginAllowThreads();
23787 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23788 wxPyEndAllowThreads(__tstate);
23789 if (PyErr_Occurred()) SWIG_fail;
23790 }
23791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23792 return resultobj;
23793 fail:
23794 return NULL;
23795 }
23796
23797
23798 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23799 PyObject *obj;
23800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23801 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23802 return SWIG_Py_Void();
23803 }
23804
23805 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23806 return SWIG_Python_InitShadowInstance(args);
23807 }
23808
23809 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23810 PyObject *resultobj = 0;
23811 int arg1 = (int) 0 ;
23812 wxDC *arg2 = (wxDC *) NULL ;
23813 wxEraseEvent *result = 0 ;
23814 int val1 ;
23815 int ecode1 = 0 ;
23816 void *argp2 = 0 ;
23817 int res2 = 0 ;
23818 PyObject * obj0 = 0 ;
23819 PyObject * obj1 = 0 ;
23820 char * kwnames[] = {
23821 (char *) "Id",(char *) "dc", NULL
23822 };
23823
23824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23825 if (obj0) {
23826 ecode1 = SWIG_AsVal_int(obj0, &val1);
23827 if (!SWIG_IsOK(ecode1)) {
23828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23829 }
23830 arg1 = static_cast< int >(val1);
23831 }
23832 if (obj1) {
23833 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23834 if (!SWIG_IsOK(res2)) {
23835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23836 }
23837 arg2 = reinterpret_cast< wxDC * >(argp2);
23838 }
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23846 return resultobj;
23847 fail:
23848 return NULL;
23849 }
23850
23851
23852 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23853 PyObject *resultobj = 0;
23854 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23855 wxDC *result = 0 ;
23856 void *argp1 = 0 ;
23857 int res1 = 0 ;
23858 PyObject *swig_obj[1] ;
23859
23860 if (!args) SWIG_fail;
23861 swig_obj[0] = args;
23862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23863 if (!SWIG_IsOK(res1)) {
23864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23865 }
23866 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23867 {
23868 PyThreadState* __tstate = wxPyBeginAllowThreads();
23869 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23870 wxPyEndAllowThreads(__tstate);
23871 if (PyErr_Occurred()) SWIG_fail;
23872 }
23873 {
23874 resultobj = wxPyMake_wxObject(result, (bool)0);
23875 }
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23883 PyObject *obj;
23884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23885 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23886 return SWIG_Py_Void();
23887 }
23888
23889 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23890 return SWIG_Python_InitShadowInstance(args);
23891 }
23892
23893 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23894 PyObject *resultobj = 0;
23895 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23896 int arg2 = (int) 0 ;
23897 wxFocusEvent *result = 0 ;
23898 int val1 ;
23899 int ecode1 = 0 ;
23900 int val2 ;
23901 int ecode2 = 0 ;
23902 PyObject * obj0 = 0 ;
23903 PyObject * obj1 = 0 ;
23904 char * kwnames[] = {
23905 (char *) "type",(char *) "winid", NULL
23906 };
23907
23908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23909 if (obj0) {
23910 ecode1 = SWIG_AsVal_int(obj0, &val1);
23911 if (!SWIG_IsOK(ecode1)) {
23912 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23913 }
23914 arg1 = static_cast< wxEventType >(val1);
23915 }
23916 if (obj1) {
23917 ecode2 = SWIG_AsVal_int(obj1, &val2);
23918 if (!SWIG_IsOK(ecode2)) {
23919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23920 }
23921 arg2 = static_cast< int >(val2);
23922 }
23923 {
23924 PyThreadState* __tstate = wxPyBeginAllowThreads();
23925 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23926 wxPyEndAllowThreads(__tstate);
23927 if (PyErr_Occurred()) SWIG_fail;
23928 }
23929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23930 return resultobj;
23931 fail:
23932 return NULL;
23933 }
23934
23935
23936 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23937 PyObject *resultobj = 0;
23938 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23939 wxWindow *result = 0 ;
23940 void *argp1 = 0 ;
23941 int res1 = 0 ;
23942 PyObject *swig_obj[1] ;
23943
23944 if (!args) SWIG_fail;
23945 swig_obj[0] = args;
23946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23947 if (!SWIG_IsOK(res1)) {
23948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23949 }
23950 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23951 {
23952 PyThreadState* __tstate = wxPyBeginAllowThreads();
23953 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23954 wxPyEndAllowThreads(__tstate);
23955 if (PyErr_Occurred()) SWIG_fail;
23956 }
23957 {
23958 resultobj = wxPyMake_wxObject(result, (bool)0);
23959 }
23960 return resultobj;
23961 fail:
23962 return NULL;
23963 }
23964
23965
23966 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23967 PyObject *resultobj = 0;
23968 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23969 wxWindow *arg2 = (wxWindow *) 0 ;
23970 void *argp1 = 0 ;
23971 int res1 = 0 ;
23972 void *argp2 = 0 ;
23973 int res2 = 0 ;
23974 PyObject * obj0 = 0 ;
23975 PyObject * obj1 = 0 ;
23976 char * kwnames[] = {
23977 (char *) "self",(char *) "win", NULL
23978 };
23979
23980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23982 if (!SWIG_IsOK(res1)) {
23983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23984 }
23985 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23986 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23987 if (!SWIG_IsOK(res2)) {
23988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23989 }
23990 arg2 = reinterpret_cast< wxWindow * >(argp2);
23991 {
23992 PyThreadState* __tstate = wxPyBeginAllowThreads();
23993 (arg1)->SetWindow(arg2);
23994 wxPyEndAllowThreads(__tstate);
23995 if (PyErr_Occurred()) SWIG_fail;
23996 }
23997 resultobj = SWIG_Py_Void();
23998 return resultobj;
23999 fail:
24000 return NULL;
24001 }
24002
24003
24004 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24005 PyObject *obj;
24006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24007 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24008 return SWIG_Py_Void();
24009 }
24010
24011 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24012 return SWIG_Python_InitShadowInstance(args);
24013 }
24014
24015 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24016 PyObject *resultobj = 0;
24017 wxWindow *arg1 = (wxWindow *) NULL ;
24018 wxChildFocusEvent *result = 0 ;
24019 void *argp1 = 0 ;
24020 int res1 = 0 ;
24021 PyObject * obj0 = 0 ;
24022 char * kwnames[] = {
24023 (char *) "win", NULL
24024 };
24025
24026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24027 if (obj0) {
24028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24029 if (!SWIG_IsOK(res1)) {
24030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24031 }
24032 arg1 = reinterpret_cast< wxWindow * >(argp1);
24033 }
24034 {
24035 PyThreadState* __tstate = wxPyBeginAllowThreads();
24036 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24037 wxPyEndAllowThreads(__tstate);
24038 if (PyErr_Occurred()) SWIG_fail;
24039 }
24040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24041 return resultobj;
24042 fail:
24043 return NULL;
24044 }
24045
24046
24047 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24048 PyObject *resultobj = 0;
24049 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24050 wxWindow *result = 0 ;
24051 void *argp1 = 0 ;
24052 int res1 = 0 ;
24053 PyObject *swig_obj[1] ;
24054
24055 if (!args) SWIG_fail;
24056 swig_obj[0] = args;
24057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24058 if (!SWIG_IsOK(res1)) {
24059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24060 }
24061 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24062 {
24063 PyThreadState* __tstate = wxPyBeginAllowThreads();
24064 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24065 wxPyEndAllowThreads(__tstate);
24066 if (PyErr_Occurred()) SWIG_fail;
24067 }
24068 {
24069 resultobj = wxPyMake_wxObject(result, (bool)0);
24070 }
24071 return resultobj;
24072 fail:
24073 return NULL;
24074 }
24075
24076
24077 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24078 PyObject *obj;
24079 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24080 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24081 return SWIG_Py_Void();
24082 }
24083
24084 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24085 return SWIG_Python_InitShadowInstance(args);
24086 }
24087
24088 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24089 PyObject *resultobj = 0;
24090 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24091 bool arg2 = (bool) true ;
24092 int arg3 = (int) 0 ;
24093 wxActivateEvent *result = 0 ;
24094 int val1 ;
24095 int ecode1 = 0 ;
24096 bool val2 ;
24097 int ecode2 = 0 ;
24098 int val3 ;
24099 int ecode3 = 0 ;
24100 PyObject * obj0 = 0 ;
24101 PyObject * obj1 = 0 ;
24102 PyObject * obj2 = 0 ;
24103 char * kwnames[] = {
24104 (char *) "type",(char *) "active",(char *) "Id", NULL
24105 };
24106
24107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24108 if (obj0) {
24109 ecode1 = SWIG_AsVal_int(obj0, &val1);
24110 if (!SWIG_IsOK(ecode1)) {
24111 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24112 }
24113 arg1 = static_cast< wxEventType >(val1);
24114 }
24115 if (obj1) {
24116 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24117 if (!SWIG_IsOK(ecode2)) {
24118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24119 }
24120 arg2 = static_cast< bool >(val2);
24121 }
24122 if (obj2) {
24123 ecode3 = SWIG_AsVal_int(obj2, &val3);
24124 if (!SWIG_IsOK(ecode3)) {
24125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24126 }
24127 arg3 = static_cast< int >(val3);
24128 }
24129 {
24130 PyThreadState* __tstate = wxPyBeginAllowThreads();
24131 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24132 wxPyEndAllowThreads(__tstate);
24133 if (PyErr_Occurred()) SWIG_fail;
24134 }
24135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24136 return resultobj;
24137 fail:
24138 return NULL;
24139 }
24140
24141
24142 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24143 PyObject *resultobj = 0;
24144 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24145 bool result;
24146 void *argp1 = 0 ;
24147 int res1 = 0 ;
24148 PyObject *swig_obj[1] ;
24149
24150 if (!args) SWIG_fail;
24151 swig_obj[0] = args;
24152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24153 if (!SWIG_IsOK(res1)) {
24154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24155 }
24156 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24157 {
24158 PyThreadState* __tstate = wxPyBeginAllowThreads();
24159 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24160 wxPyEndAllowThreads(__tstate);
24161 if (PyErr_Occurred()) SWIG_fail;
24162 }
24163 {
24164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24165 }
24166 return resultobj;
24167 fail:
24168 return NULL;
24169 }
24170
24171
24172 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24173 PyObject *obj;
24174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24175 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24176 return SWIG_Py_Void();
24177 }
24178
24179 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24180 return SWIG_Python_InitShadowInstance(args);
24181 }
24182
24183 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24184 PyObject *resultobj = 0;
24185 int arg1 = (int) 0 ;
24186 wxInitDialogEvent *result = 0 ;
24187 int val1 ;
24188 int ecode1 = 0 ;
24189 PyObject * obj0 = 0 ;
24190 char * kwnames[] = {
24191 (char *) "Id", NULL
24192 };
24193
24194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24195 if (obj0) {
24196 ecode1 = SWIG_AsVal_int(obj0, &val1);
24197 if (!SWIG_IsOK(ecode1)) {
24198 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24199 }
24200 arg1 = static_cast< int >(val1);
24201 }
24202 {
24203 PyThreadState* __tstate = wxPyBeginAllowThreads();
24204 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24205 wxPyEndAllowThreads(__tstate);
24206 if (PyErr_Occurred()) SWIG_fail;
24207 }
24208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24209 return resultobj;
24210 fail:
24211 return NULL;
24212 }
24213
24214
24215 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24216 PyObject *obj;
24217 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24218 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24219 return SWIG_Py_Void();
24220 }
24221
24222 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24223 return SWIG_Python_InitShadowInstance(args);
24224 }
24225
24226 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24227 PyObject *resultobj = 0;
24228 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24229 int arg2 = (int) 0 ;
24230 wxMenu *arg3 = (wxMenu *) NULL ;
24231 wxMenuEvent *result = 0 ;
24232 int val1 ;
24233 int ecode1 = 0 ;
24234 int val2 ;
24235 int ecode2 = 0 ;
24236 void *argp3 = 0 ;
24237 int res3 = 0 ;
24238 PyObject * obj0 = 0 ;
24239 PyObject * obj1 = 0 ;
24240 PyObject * obj2 = 0 ;
24241 char * kwnames[] = {
24242 (char *) "type",(char *) "winid",(char *) "menu", NULL
24243 };
24244
24245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24246 if (obj0) {
24247 ecode1 = SWIG_AsVal_int(obj0, &val1);
24248 if (!SWIG_IsOK(ecode1)) {
24249 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24250 }
24251 arg1 = static_cast< wxEventType >(val1);
24252 }
24253 if (obj1) {
24254 ecode2 = SWIG_AsVal_int(obj1, &val2);
24255 if (!SWIG_IsOK(ecode2)) {
24256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24257 }
24258 arg2 = static_cast< int >(val2);
24259 }
24260 if (obj2) {
24261 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24262 if (!SWIG_IsOK(res3)) {
24263 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24264 }
24265 arg3 = reinterpret_cast< wxMenu * >(argp3);
24266 }
24267 {
24268 PyThreadState* __tstate = wxPyBeginAllowThreads();
24269 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24270 wxPyEndAllowThreads(__tstate);
24271 if (PyErr_Occurred()) SWIG_fail;
24272 }
24273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24274 return resultobj;
24275 fail:
24276 return NULL;
24277 }
24278
24279
24280 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24281 PyObject *resultobj = 0;
24282 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24283 int result;
24284 void *argp1 = 0 ;
24285 int res1 = 0 ;
24286 PyObject *swig_obj[1] ;
24287
24288 if (!args) SWIG_fail;
24289 swig_obj[0] = args;
24290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24291 if (!SWIG_IsOK(res1)) {
24292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24293 }
24294 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24295 {
24296 PyThreadState* __tstate = wxPyBeginAllowThreads();
24297 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24298 wxPyEndAllowThreads(__tstate);
24299 if (PyErr_Occurred()) SWIG_fail;
24300 }
24301 resultobj = SWIG_From_int(static_cast< int >(result));
24302 return resultobj;
24303 fail:
24304 return NULL;
24305 }
24306
24307
24308 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24309 PyObject *resultobj = 0;
24310 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24311 bool result;
24312 void *argp1 = 0 ;
24313 int res1 = 0 ;
24314 PyObject *swig_obj[1] ;
24315
24316 if (!args) SWIG_fail;
24317 swig_obj[0] = args;
24318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24319 if (!SWIG_IsOK(res1)) {
24320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24321 }
24322 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24323 {
24324 PyThreadState* __tstate = wxPyBeginAllowThreads();
24325 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24326 wxPyEndAllowThreads(__tstate);
24327 if (PyErr_Occurred()) SWIG_fail;
24328 }
24329 {
24330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24331 }
24332 return resultobj;
24333 fail:
24334 return NULL;
24335 }
24336
24337
24338 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24339 PyObject *resultobj = 0;
24340 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24341 wxMenu *result = 0 ;
24342 void *argp1 = 0 ;
24343 int res1 = 0 ;
24344 PyObject *swig_obj[1] ;
24345
24346 if (!args) SWIG_fail;
24347 swig_obj[0] = args;
24348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24349 if (!SWIG_IsOK(res1)) {
24350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24351 }
24352 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24353 {
24354 PyThreadState* __tstate = wxPyBeginAllowThreads();
24355 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24356 wxPyEndAllowThreads(__tstate);
24357 if (PyErr_Occurred()) SWIG_fail;
24358 }
24359 {
24360 resultobj = wxPyMake_wxObject(result, (bool)0);
24361 }
24362 return resultobj;
24363 fail:
24364 return NULL;
24365 }
24366
24367
24368 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24369 PyObject *obj;
24370 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24371 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24372 return SWIG_Py_Void();
24373 }
24374
24375 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24376 return SWIG_Python_InitShadowInstance(args);
24377 }
24378
24379 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24380 PyObject *resultobj = 0;
24381 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24382 int arg2 = (int) 0 ;
24383 wxCloseEvent *result = 0 ;
24384 int val1 ;
24385 int ecode1 = 0 ;
24386 int val2 ;
24387 int ecode2 = 0 ;
24388 PyObject * obj0 = 0 ;
24389 PyObject * obj1 = 0 ;
24390 char * kwnames[] = {
24391 (char *) "type",(char *) "winid", NULL
24392 };
24393
24394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24395 if (obj0) {
24396 ecode1 = SWIG_AsVal_int(obj0, &val1);
24397 if (!SWIG_IsOK(ecode1)) {
24398 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24399 }
24400 arg1 = static_cast< wxEventType >(val1);
24401 }
24402 if (obj1) {
24403 ecode2 = SWIG_AsVal_int(obj1, &val2);
24404 if (!SWIG_IsOK(ecode2)) {
24405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24406 }
24407 arg2 = static_cast< int >(val2);
24408 }
24409 {
24410 PyThreadState* __tstate = wxPyBeginAllowThreads();
24411 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24412 wxPyEndAllowThreads(__tstate);
24413 if (PyErr_Occurred()) SWIG_fail;
24414 }
24415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24416 return resultobj;
24417 fail:
24418 return NULL;
24419 }
24420
24421
24422 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24423 PyObject *resultobj = 0;
24424 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24425 bool arg2 ;
24426 void *argp1 = 0 ;
24427 int res1 = 0 ;
24428 bool val2 ;
24429 int ecode2 = 0 ;
24430 PyObject * obj0 = 0 ;
24431 PyObject * obj1 = 0 ;
24432 char * kwnames[] = {
24433 (char *) "self",(char *) "logOff", NULL
24434 };
24435
24436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24438 if (!SWIG_IsOK(res1)) {
24439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24440 }
24441 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24442 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24443 if (!SWIG_IsOK(ecode2)) {
24444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24445 }
24446 arg2 = static_cast< bool >(val2);
24447 {
24448 PyThreadState* __tstate = wxPyBeginAllowThreads();
24449 (arg1)->SetLoggingOff(arg2);
24450 wxPyEndAllowThreads(__tstate);
24451 if (PyErr_Occurred()) SWIG_fail;
24452 }
24453 resultobj = SWIG_Py_Void();
24454 return resultobj;
24455 fail:
24456 return NULL;
24457 }
24458
24459
24460 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24461 PyObject *resultobj = 0;
24462 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24463 bool result;
24464 void *argp1 = 0 ;
24465 int res1 = 0 ;
24466 PyObject *swig_obj[1] ;
24467
24468 if (!args) SWIG_fail;
24469 swig_obj[0] = args;
24470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24471 if (!SWIG_IsOK(res1)) {
24472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24473 }
24474 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24475 {
24476 PyThreadState* __tstate = wxPyBeginAllowThreads();
24477 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24478 wxPyEndAllowThreads(__tstate);
24479 if (PyErr_Occurred()) SWIG_fail;
24480 }
24481 {
24482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24483 }
24484 return resultobj;
24485 fail:
24486 return NULL;
24487 }
24488
24489
24490 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24491 PyObject *resultobj = 0;
24492 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24493 bool arg2 = (bool) true ;
24494 void *argp1 = 0 ;
24495 int res1 = 0 ;
24496 bool val2 ;
24497 int ecode2 = 0 ;
24498 PyObject * obj0 = 0 ;
24499 PyObject * obj1 = 0 ;
24500 char * kwnames[] = {
24501 (char *) "self",(char *) "veto", NULL
24502 };
24503
24504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24506 if (!SWIG_IsOK(res1)) {
24507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24508 }
24509 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24510 if (obj1) {
24511 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24512 if (!SWIG_IsOK(ecode2)) {
24513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24514 }
24515 arg2 = static_cast< bool >(val2);
24516 }
24517 {
24518 PyThreadState* __tstate = wxPyBeginAllowThreads();
24519 (arg1)->Veto(arg2);
24520 wxPyEndAllowThreads(__tstate);
24521 if (PyErr_Occurred()) SWIG_fail;
24522 }
24523 resultobj = SWIG_Py_Void();
24524 return resultobj;
24525 fail:
24526 return NULL;
24527 }
24528
24529
24530 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24531 PyObject *resultobj = 0;
24532 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24533 bool result;
24534 void *argp1 = 0 ;
24535 int res1 = 0 ;
24536 PyObject *swig_obj[1] ;
24537
24538 if (!args) SWIG_fail;
24539 swig_obj[0] = args;
24540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24541 if (!SWIG_IsOK(res1)) {
24542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24543 }
24544 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24545 {
24546 PyThreadState* __tstate = wxPyBeginAllowThreads();
24547 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24548 wxPyEndAllowThreads(__tstate);
24549 if (PyErr_Occurred()) SWIG_fail;
24550 }
24551 {
24552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24553 }
24554 return resultobj;
24555 fail:
24556 return NULL;
24557 }
24558
24559
24560 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24561 PyObject *resultobj = 0;
24562 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24563 bool arg2 ;
24564 void *argp1 = 0 ;
24565 int res1 = 0 ;
24566 bool val2 ;
24567 int ecode2 = 0 ;
24568 PyObject * obj0 = 0 ;
24569 PyObject * obj1 = 0 ;
24570 char * kwnames[] = {
24571 (char *) "self",(char *) "canVeto", NULL
24572 };
24573
24574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24576 if (!SWIG_IsOK(res1)) {
24577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24578 }
24579 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24580 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24581 if (!SWIG_IsOK(ecode2)) {
24582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24583 }
24584 arg2 = static_cast< bool >(val2);
24585 {
24586 PyThreadState* __tstate = wxPyBeginAllowThreads();
24587 (arg1)->SetCanVeto(arg2);
24588 wxPyEndAllowThreads(__tstate);
24589 if (PyErr_Occurred()) SWIG_fail;
24590 }
24591 resultobj = SWIG_Py_Void();
24592 return resultobj;
24593 fail:
24594 return NULL;
24595 }
24596
24597
24598 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24599 PyObject *resultobj = 0;
24600 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24601 bool result;
24602 void *argp1 = 0 ;
24603 int res1 = 0 ;
24604 PyObject *swig_obj[1] ;
24605
24606 if (!args) SWIG_fail;
24607 swig_obj[0] = args;
24608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24609 if (!SWIG_IsOK(res1)) {
24610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24611 }
24612 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24613 {
24614 PyThreadState* __tstate = wxPyBeginAllowThreads();
24615 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24616 wxPyEndAllowThreads(__tstate);
24617 if (PyErr_Occurred()) SWIG_fail;
24618 }
24619 {
24620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24621 }
24622 return resultobj;
24623 fail:
24624 return NULL;
24625 }
24626
24627
24628 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24629 PyObject *obj;
24630 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24631 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24632 return SWIG_Py_Void();
24633 }
24634
24635 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24636 return SWIG_Python_InitShadowInstance(args);
24637 }
24638
24639 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24640 PyObject *resultobj = 0;
24641 int arg1 = (int) 0 ;
24642 bool arg2 = (bool) false ;
24643 wxShowEvent *result = 0 ;
24644 int val1 ;
24645 int ecode1 = 0 ;
24646 bool val2 ;
24647 int ecode2 = 0 ;
24648 PyObject * obj0 = 0 ;
24649 PyObject * obj1 = 0 ;
24650 char * kwnames[] = {
24651 (char *) "winid",(char *) "show", NULL
24652 };
24653
24654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24655 if (obj0) {
24656 ecode1 = SWIG_AsVal_int(obj0, &val1);
24657 if (!SWIG_IsOK(ecode1)) {
24658 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24659 }
24660 arg1 = static_cast< int >(val1);
24661 }
24662 if (obj1) {
24663 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24664 if (!SWIG_IsOK(ecode2)) {
24665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24666 }
24667 arg2 = static_cast< bool >(val2);
24668 }
24669 {
24670 PyThreadState* __tstate = wxPyBeginAllowThreads();
24671 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24672 wxPyEndAllowThreads(__tstate);
24673 if (PyErr_Occurred()) SWIG_fail;
24674 }
24675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24676 return resultobj;
24677 fail:
24678 return NULL;
24679 }
24680
24681
24682 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24683 PyObject *resultobj = 0;
24684 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24685 bool arg2 ;
24686 void *argp1 = 0 ;
24687 int res1 = 0 ;
24688 bool val2 ;
24689 int ecode2 = 0 ;
24690 PyObject * obj0 = 0 ;
24691 PyObject * obj1 = 0 ;
24692 char * kwnames[] = {
24693 (char *) "self",(char *) "show", NULL
24694 };
24695
24696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24698 if (!SWIG_IsOK(res1)) {
24699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24700 }
24701 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24702 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24703 if (!SWIG_IsOK(ecode2)) {
24704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24705 }
24706 arg2 = static_cast< bool >(val2);
24707 {
24708 PyThreadState* __tstate = wxPyBeginAllowThreads();
24709 (arg1)->SetShow(arg2);
24710 wxPyEndAllowThreads(__tstate);
24711 if (PyErr_Occurred()) SWIG_fail;
24712 }
24713 resultobj = SWIG_Py_Void();
24714 return resultobj;
24715 fail:
24716 return NULL;
24717 }
24718
24719
24720 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24721 PyObject *resultobj = 0;
24722 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24723 bool result;
24724 void *argp1 = 0 ;
24725 int res1 = 0 ;
24726 PyObject *swig_obj[1] ;
24727
24728 if (!args) SWIG_fail;
24729 swig_obj[0] = args;
24730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24731 if (!SWIG_IsOK(res1)) {
24732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24733 }
24734 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24735 {
24736 PyThreadState* __tstate = wxPyBeginAllowThreads();
24737 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24738 wxPyEndAllowThreads(__tstate);
24739 if (PyErr_Occurred()) SWIG_fail;
24740 }
24741 {
24742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24743 }
24744 return resultobj;
24745 fail:
24746 return NULL;
24747 }
24748
24749
24750 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24751 PyObject *obj;
24752 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24753 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24754 return SWIG_Py_Void();
24755 }
24756
24757 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24758 return SWIG_Python_InitShadowInstance(args);
24759 }
24760
24761 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24762 PyObject *resultobj = 0;
24763 int arg1 = (int) 0 ;
24764 bool arg2 = (bool) true ;
24765 wxIconizeEvent *result = 0 ;
24766 int val1 ;
24767 int ecode1 = 0 ;
24768 bool val2 ;
24769 int ecode2 = 0 ;
24770 PyObject * obj0 = 0 ;
24771 PyObject * obj1 = 0 ;
24772 char * kwnames[] = {
24773 (char *) "id",(char *) "iconized", NULL
24774 };
24775
24776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24777 if (obj0) {
24778 ecode1 = SWIG_AsVal_int(obj0, &val1);
24779 if (!SWIG_IsOK(ecode1)) {
24780 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24781 }
24782 arg1 = static_cast< int >(val1);
24783 }
24784 if (obj1) {
24785 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24786 if (!SWIG_IsOK(ecode2)) {
24787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24788 }
24789 arg2 = static_cast< bool >(val2);
24790 }
24791 {
24792 PyThreadState* __tstate = wxPyBeginAllowThreads();
24793 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24794 wxPyEndAllowThreads(__tstate);
24795 if (PyErr_Occurred()) SWIG_fail;
24796 }
24797 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24798 return resultobj;
24799 fail:
24800 return NULL;
24801 }
24802
24803
24804 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24805 PyObject *resultobj = 0;
24806 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24807 bool result;
24808 void *argp1 = 0 ;
24809 int res1 = 0 ;
24810 PyObject *swig_obj[1] ;
24811
24812 if (!args) SWIG_fail;
24813 swig_obj[0] = args;
24814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24815 if (!SWIG_IsOK(res1)) {
24816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24817 }
24818 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24819 {
24820 PyThreadState* __tstate = wxPyBeginAllowThreads();
24821 result = (bool)(arg1)->Iconized();
24822 wxPyEndAllowThreads(__tstate);
24823 if (PyErr_Occurred()) SWIG_fail;
24824 }
24825 {
24826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24827 }
24828 return resultobj;
24829 fail:
24830 return NULL;
24831 }
24832
24833
24834 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24835 PyObject *obj;
24836 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24837 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24838 return SWIG_Py_Void();
24839 }
24840
24841 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24842 return SWIG_Python_InitShadowInstance(args);
24843 }
24844
24845 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24846 PyObject *resultobj = 0;
24847 int arg1 = (int) 0 ;
24848 wxMaximizeEvent *result = 0 ;
24849 int val1 ;
24850 int ecode1 = 0 ;
24851 PyObject * obj0 = 0 ;
24852 char * kwnames[] = {
24853 (char *) "id", NULL
24854 };
24855
24856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24857 if (obj0) {
24858 ecode1 = SWIG_AsVal_int(obj0, &val1);
24859 if (!SWIG_IsOK(ecode1)) {
24860 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24861 }
24862 arg1 = static_cast< int >(val1);
24863 }
24864 {
24865 PyThreadState* __tstate = wxPyBeginAllowThreads();
24866 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24867 wxPyEndAllowThreads(__tstate);
24868 if (PyErr_Occurred()) SWIG_fail;
24869 }
24870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24871 return resultobj;
24872 fail:
24873 return NULL;
24874 }
24875
24876
24877 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24878 PyObject *obj;
24879 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24880 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24881 return SWIG_Py_Void();
24882 }
24883
24884 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24885 return SWIG_Python_InitShadowInstance(args);
24886 }
24887
24888 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24889 PyObject *resultobj = 0;
24890 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24891 wxPoint result;
24892 void *argp1 = 0 ;
24893 int res1 = 0 ;
24894 PyObject *swig_obj[1] ;
24895
24896 if (!args) SWIG_fail;
24897 swig_obj[0] = args;
24898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24899 if (!SWIG_IsOK(res1)) {
24900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24901 }
24902 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24903 {
24904 PyThreadState* __tstate = wxPyBeginAllowThreads();
24905 result = (arg1)->GetPosition();
24906 wxPyEndAllowThreads(__tstate);
24907 if (PyErr_Occurred()) SWIG_fail;
24908 }
24909 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24910 return resultobj;
24911 fail:
24912 return NULL;
24913 }
24914
24915
24916 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24917 PyObject *resultobj = 0;
24918 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24919 int result;
24920 void *argp1 = 0 ;
24921 int res1 = 0 ;
24922 PyObject *swig_obj[1] ;
24923
24924 if (!args) SWIG_fail;
24925 swig_obj[0] = args;
24926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24927 if (!SWIG_IsOK(res1)) {
24928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24929 }
24930 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24931 {
24932 PyThreadState* __tstate = wxPyBeginAllowThreads();
24933 result = (int)(arg1)->GetNumberOfFiles();
24934 wxPyEndAllowThreads(__tstate);
24935 if (PyErr_Occurred()) SWIG_fail;
24936 }
24937 resultobj = SWIG_From_int(static_cast< int >(result));
24938 return resultobj;
24939 fail:
24940 return NULL;
24941 }
24942
24943
24944 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24945 PyObject *resultobj = 0;
24946 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24947 PyObject *result = 0 ;
24948 void *argp1 = 0 ;
24949 int res1 = 0 ;
24950 PyObject *swig_obj[1] ;
24951
24952 if (!args) SWIG_fail;
24953 swig_obj[0] = args;
24954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24955 if (!SWIG_IsOK(res1)) {
24956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24957 }
24958 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24959 {
24960 PyThreadState* __tstate = wxPyBeginAllowThreads();
24961 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24962 wxPyEndAllowThreads(__tstate);
24963 if (PyErr_Occurred()) SWIG_fail;
24964 }
24965 resultobj = result;
24966 return resultobj;
24967 fail:
24968 return NULL;
24969 }
24970
24971
24972 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24973 PyObject *obj;
24974 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24975 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24976 return SWIG_Py_Void();
24977 }
24978
24979 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24980 PyObject *resultobj = 0;
24981 int arg1 = (int) 0 ;
24982 wxUpdateUIEvent *result = 0 ;
24983 int val1 ;
24984 int ecode1 = 0 ;
24985 PyObject * obj0 = 0 ;
24986 char * kwnames[] = {
24987 (char *) "commandId", NULL
24988 };
24989
24990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24991 if (obj0) {
24992 ecode1 = SWIG_AsVal_int(obj0, &val1);
24993 if (!SWIG_IsOK(ecode1)) {
24994 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24995 }
24996 arg1 = static_cast< int >(val1);
24997 }
24998 {
24999 PyThreadState* __tstate = wxPyBeginAllowThreads();
25000 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25001 wxPyEndAllowThreads(__tstate);
25002 if (PyErr_Occurred()) SWIG_fail;
25003 }
25004 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25005 return resultobj;
25006 fail:
25007 return NULL;
25008 }
25009
25010
25011 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25012 PyObject *resultobj = 0;
25013 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25014 bool result;
25015 void *argp1 = 0 ;
25016 int res1 = 0 ;
25017 PyObject *swig_obj[1] ;
25018
25019 if (!args) SWIG_fail;
25020 swig_obj[0] = args;
25021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25022 if (!SWIG_IsOK(res1)) {
25023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25024 }
25025 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25026 {
25027 PyThreadState* __tstate = wxPyBeginAllowThreads();
25028 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25029 wxPyEndAllowThreads(__tstate);
25030 if (PyErr_Occurred()) SWIG_fail;
25031 }
25032 {
25033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25034 }
25035 return resultobj;
25036 fail:
25037 return NULL;
25038 }
25039
25040
25041 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25042 PyObject *resultobj = 0;
25043 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25044 bool result;
25045 void *argp1 = 0 ;
25046 int res1 = 0 ;
25047 PyObject *swig_obj[1] ;
25048
25049 if (!args) SWIG_fail;
25050 swig_obj[0] = args;
25051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25052 if (!SWIG_IsOK(res1)) {
25053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25054 }
25055 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25056 {
25057 PyThreadState* __tstate = wxPyBeginAllowThreads();
25058 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25059 wxPyEndAllowThreads(__tstate);
25060 if (PyErr_Occurred()) SWIG_fail;
25061 }
25062 {
25063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25064 }
25065 return resultobj;
25066 fail:
25067 return NULL;
25068 }
25069
25070
25071 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25072 PyObject *resultobj = 0;
25073 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25074 bool result;
25075 void *argp1 = 0 ;
25076 int res1 = 0 ;
25077 PyObject *swig_obj[1] ;
25078
25079 if (!args) SWIG_fail;
25080 swig_obj[0] = args;
25081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25082 if (!SWIG_IsOK(res1)) {
25083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25084 }
25085 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25086 {
25087 PyThreadState* __tstate = wxPyBeginAllowThreads();
25088 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25089 wxPyEndAllowThreads(__tstate);
25090 if (PyErr_Occurred()) SWIG_fail;
25091 }
25092 {
25093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25094 }
25095 return resultobj;
25096 fail:
25097 return NULL;
25098 }
25099
25100
25101 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25102 PyObject *resultobj = 0;
25103 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25104 wxString result;
25105 void *argp1 = 0 ;
25106 int res1 = 0 ;
25107 PyObject *swig_obj[1] ;
25108
25109 if (!args) SWIG_fail;
25110 swig_obj[0] = args;
25111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25112 if (!SWIG_IsOK(res1)) {
25113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25114 }
25115 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25116 {
25117 PyThreadState* __tstate = wxPyBeginAllowThreads();
25118 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25119 wxPyEndAllowThreads(__tstate);
25120 if (PyErr_Occurred()) SWIG_fail;
25121 }
25122 {
25123 #if wxUSE_UNICODE
25124 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25125 #else
25126 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25127 #endif
25128 }
25129 return resultobj;
25130 fail:
25131 return NULL;
25132 }
25133
25134
25135 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25136 PyObject *resultobj = 0;
25137 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25138 bool result;
25139 void *argp1 = 0 ;
25140 int res1 = 0 ;
25141 PyObject *swig_obj[1] ;
25142
25143 if (!args) SWIG_fail;
25144 swig_obj[0] = args;
25145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25146 if (!SWIG_IsOK(res1)) {
25147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25148 }
25149 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25150 {
25151 PyThreadState* __tstate = wxPyBeginAllowThreads();
25152 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25153 wxPyEndAllowThreads(__tstate);
25154 if (PyErr_Occurred()) SWIG_fail;
25155 }
25156 {
25157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25158 }
25159 return resultobj;
25160 fail:
25161 return NULL;
25162 }
25163
25164
25165 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25166 PyObject *resultobj = 0;
25167 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25168 bool result;
25169 void *argp1 = 0 ;
25170 int res1 = 0 ;
25171 PyObject *swig_obj[1] ;
25172
25173 if (!args) SWIG_fail;
25174 swig_obj[0] = args;
25175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25176 if (!SWIG_IsOK(res1)) {
25177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25178 }
25179 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25180 {
25181 PyThreadState* __tstate = wxPyBeginAllowThreads();
25182 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25183 wxPyEndAllowThreads(__tstate);
25184 if (PyErr_Occurred()) SWIG_fail;
25185 }
25186 {
25187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25188 }
25189 return resultobj;
25190 fail:
25191 return NULL;
25192 }
25193
25194
25195 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25196 PyObject *resultobj = 0;
25197 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25198 bool result;
25199 void *argp1 = 0 ;
25200 int res1 = 0 ;
25201 PyObject *swig_obj[1] ;
25202
25203 if (!args) SWIG_fail;
25204 swig_obj[0] = args;
25205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25206 if (!SWIG_IsOK(res1)) {
25207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25208 }
25209 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25210 {
25211 PyThreadState* __tstate = wxPyBeginAllowThreads();
25212 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25213 wxPyEndAllowThreads(__tstate);
25214 if (PyErr_Occurred()) SWIG_fail;
25215 }
25216 {
25217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25218 }
25219 return resultobj;
25220 fail:
25221 return NULL;
25222 }
25223
25224
25225 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25226 PyObject *resultobj = 0;
25227 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25228 bool result;
25229 void *argp1 = 0 ;
25230 int res1 = 0 ;
25231 PyObject *swig_obj[1] ;
25232
25233 if (!args) SWIG_fail;
25234 swig_obj[0] = args;
25235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25236 if (!SWIG_IsOK(res1)) {
25237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25238 }
25239 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25240 {
25241 PyThreadState* __tstate = wxPyBeginAllowThreads();
25242 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25243 wxPyEndAllowThreads(__tstate);
25244 if (PyErr_Occurred()) SWIG_fail;
25245 }
25246 {
25247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25248 }
25249 return resultobj;
25250 fail:
25251 return NULL;
25252 }
25253
25254
25255 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25256 PyObject *resultobj = 0;
25257 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25258 bool arg2 ;
25259 void *argp1 = 0 ;
25260 int res1 = 0 ;
25261 bool val2 ;
25262 int ecode2 = 0 ;
25263 PyObject * obj0 = 0 ;
25264 PyObject * obj1 = 0 ;
25265 char * kwnames[] = {
25266 (char *) "self",(char *) "check", NULL
25267 };
25268
25269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25271 if (!SWIG_IsOK(res1)) {
25272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25273 }
25274 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25275 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25276 if (!SWIG_IsOK(ecode2)) {
25277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25278 }
25279 arg2 = static_cast< bool >(val2);
25280 {
25281 PyThreadState* __tstate = wxPyBeginAllowThreads();
25282 (arg1)->Check(arg2);
25283 wxPyEndAllowThreads(__tstate);
25284 if (PyErr_Occurred()) SWIG_fail;
25285 }
25286 resultobj = SWIG_Py_Void();
25287 return resultobj;
25288 fail:
25289 return NULL;
25290 }
25291
25292
25293 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25294 PyObject *resultobj = 0;
25295 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25296 bool arg2 ;
25297 void *argp1 = 0 ;
25298 int res1 = 0 ;
25299 bool val2 ;
25300 int ecode2 = 0 ;
25301 PyObject * obj0 = 0 ;
25302 PyObject * obj1 = 0 ;
25303 char * kwnames[] = {
25304 (char *) "self",(char *) "enable", NULL
25305 };
25306
25307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25309 if (!SWIG_IsOK(res1)) {
25310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25311 }
25312 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25313 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25314 if (!SWIG_IsOK(ecode2)) {
25315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25316 }
25317 arg2 = static_cast< bool >(val2);
25318 {
25319 PyThreadState* __tstate = wxPyBeginAllowThreads();
25320 (arg1)->Enable(arg2);
25321 wxPyEndAllowThreads(__tstate);
25322 if (PyErr_Occurred()) SWIG_fail;
25323 }
25324 resultobj = SWIG_Py_Void();
25325 return resultobj;
25326 fail:
25327 return NULL;
25328 }
25329
25330
25331 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25332 PyObject *resultobj = 0;
25333 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25334 bool arg2 ;
25335 void *argp1 = 0 ;
25336 int res1 = 0 ;
25337 bool val2 ;
25338 int ecode2 = 0 ;
25339 PyObject * obj0 = 0 ;
25340 PyObject * obj1 = 0 ;
25341 char * kwnames[] = {
25342 (char *) "self",(char *) "show", NULL
25343 };
25344
25345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25347 if (!SWIG_IsOK(res1)) {
25348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25349 }
25350 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25351 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25352 if (!SWIG_IsOK(ecode2)) {
25353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25354 }
25355 arg2 = static_cast< bool >(val2);
25356 {
25357 PyThreadState* __tstate = wxPyBeginAllowThreads();
25358 (arg1)->Show(arg2);
25359 wxPyEndAllowThreads(__tstate);
25360 if (PyErr_Occurred()) SWIG_fail;
25361 }
25362 resultobj = SWIG_Py_Void();
25363 return resultobj;
25364 fail:
25365 return NULL;
25366 }
25367
25368
25369 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25370 PyObject *resultobj = 0;
25371 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25372 wxString *arg2 = 0 ;
25373 void *argp1 = 0 ;
25374 int res1 = 0 ;
25375 bool temp2 = false ;
25376 PyObject * obj0 = 0 ;
25377 PyObject * obj1 = 0 ;
25378 char * kwnames[] = {
25379 (char *) "self",(char *) "text", NULL
25380 };
25381
25382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25384 if (!SWIG_IsOK(res1)) {
25385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25386 }
25387 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25388 {
25389 arg2 = wxString_in_helper(obj1);
25390 if (arg2 == NULL) SWIG_fail;
25391 temp2 = true;
25392 }
25393 {
25394 PyThreadState* __tstate = wxPyBeginAllowThreads();
25395 (arg1)->SetText((wxString const &)*arg2);
25396 wxPyEndAllowThreads(__tstate);
25397 if (PyErr_Occurred()) SWIG_fail;
25398 }
25399 resultobj = SWIG_Py_Void();
25400 {
25401 if (temp2)
25402 delete arg2;
25403 }
25404 return resultobj;
25405 fail:
25406 {
25407 if (temp2)
25408 delete arg2;
25409 }
25410 return NULL;
25411 }
25412
25413
25414 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25415 PyObject *resultobj = 0;
25416 long arg1 ;
25417 long val1 ;
25418 int ecode1 = 0 ;
25419 PyObject * obj0 = 0 ;
25420 char * kwnames[] = {
25421 (char *) "updateInterval", NULL
25422 };
25423
25424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25425 ecode1 = SWIG_AsVal_long(obj0, &val1);
25426 if (!SWIG_IsOK(ecode1)) {
25427 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25428 }
25429 arg1 = static_cast< long >(val1);
25430 {
25431 PyThreadState* __tstate = wxPyBeginAllowThreads();
25432 wxUpdateUIEvent::SetUpdateInterval(arg1);
25433 wxPyEndAllowThreads(__tstate);
25434 if (PyErr_Occurred()) SWIG_fail;
25435 }
25436 resultobj = SWIG_Py_Void();
25437 return resultobj;
25438 fail:
25439 return NULL;
25440 }
25441
25442
25443 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25444 PyObject *resultobj = 0;
25445 long result;
25446
25447 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25448 {
25449 PyThreadState* __tstate = wxPyBeginAllowThreads();
25450 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25451 wxPyEndAllowThreads(__tstate);
25452 if (PyErr_Occurred()) SWIG_fail;
25453 }
25454 resultobj = SWIG_From_long(static_cast< long >(result));
25455 return resultobj;
25456 fail:
25457 return NULL;
25458 }
25459
25460
25461 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25462 PyObject *resultobj = 0;
25463 wxWindow *arg1 = (wxWindow *) 0 ;
25464 bool result;
25465 void *argp1 = 0 ;
25466 int res1 = 0 ;
25467 PyObject * obj0 = 0 ;
25468 char * kwnames[] = {
25469 (char *) "win", NULL
25470 };
25471
25472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25474 if (!SWIG_IsOK(res1)) {
25475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25476 }
25477 arg1 = reinterpret_cast< wxWindow * >(argp1);
25478 {
25479 PyThreadState* __tstate = wxPyBeginAllowThreads();
25480 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25481 wxPyEndAllowThreads(__tstate);
25482 if (PyErr_Occurred()) SWIG_fail;
25483 }
25484 {
25485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25486 }
25487 return resultobj;
25488 fail:
25489 return NULL;
25490 }
25491
25492
25493 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25494 PyObject *resultobj = 0;
25495
25496 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25497 {
25498 PyThreadState* __tstate = wxPyBeginAllowThreads();
25499 wxUpdateUIEvent::ResetUpdateTime();
25500 wxPyEndAllowThreads(__tstate);
25501 if (PyErr_Occurred()) SWIG_fail;
25502 }
25503 resultobj = SWIG_Py_Void();
25504 return resultobj;
25505 fail:
25506 return NULL;
25507 }
25508
25509
25510 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25511 PyObject *resultobj = 0;
25512 wxUpdateUIMode arg1 ;
25513 int val1 ;
25514 int ecode1 = 0 ;
25515 PyObject * obj0 = 0 ;
25516 char * kwnames[] = {
25517 (char *) "mode", NULL
25518 };
25519
25520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25521 ecode1 = SWIG_AsVal_int(obj0, &val1);
25522 if (!SWIG_IsOK(ecode1)) {
25523 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25524 }
25525 arg1 = static_cast< wxUpdateUIMode >(val1);
25526 {
25527 PyThreadState* __tstate = wxPyBeginAllowThreads();
25528 wxUpdateUIEvent::SetMode(arg1);
25529 wxPyEndAllowThreads(__tstate);
25530 if (PyErr_Occurred()) SWIG_fail;
25531 }
25532 resultobj = SWIG_Py_Void();
25533 return resultobj;
25534 fail:
25535 return NULL;
25536 }
25537
25538
25539 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25540 PyObject *resultobj = 0;
25541 wxUpdateUIMode result;
25542
25543 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25544 {
25545 PyThreadState* __tstate = wxPyBeginAllowThreads();
25546 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25547 wxPyEndAllowThreads(__tstate);
25548 if (PyErr_Occurred()) SWIG_fail;
25549 }
25550 resultobj = SWIG_From_int(static_cast< int >(result));
25551 return resultobj;
25552 fail:
25553 return NULL;
25554 }
25555
25556
25557 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25558 PyObject *obj;
25559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25560 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25561 return SWIG_Py_Void();
25562 }
25563
25564 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25565 return SWIG_Python_InitShadowInstance(args);
25566 }
25567
25568 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25569 PyObject *resultobj = 0;
25570 wxSysColourChangedEvent *result = 0 ;
25571
25572 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25573 {
25574 PyThreadState* __tstate = wxPyBeginAllowThreads();
25575 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25576 wxPyEndAllowThreads(__tstate);
25577 if (PyErr_Occurred()) SWIG_fail;
25578 }
25579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25580 return resultobj;
25581 fail:
25582 return NULL;
25583 }
25584
25585
25586 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25587 PyObject *obj;
25588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25589 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25590 return SWIG_Py_Void();
25591 }
25592
25593 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25594 return SWIG_Python_InitShadowInstance(args);
25595 }
25596
25597 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25598 PyObject *resultobj = 0;
25599 int arg1 = (int) 0 ;
25600 wxWindow *arg2 = (wxWindow *) NULL ;
25601 wxMouseCaptureChangedEvent *result = 0 ;
25602 int val1 ;
25603 int ecode1 = 0 ;
25604 void *argp2 = 0 ;
25605 int res2 = 0 ;
25606 PyObject * obj0 = 0 ;
25607 PyObject * obj1 = 0 ;
25608 char * kwnames[] = {
25609 (char *) "winid",(char *) "gainedCapture", NULL
25610 };
25611
25612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25613 if (obj0) {
25614 ecode1 = SWIG_AsVal_int(obj0, &val1);
25615 if (!SWIG_IsOK(ecode1)) {
25616 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25617 }
25618 arg1 = static_cast< int >(val1);
25619 }
25620 if (obj1) {
25621 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25622 if (!SWIG_IsOK(res2)) {
25623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25624 }
25625 arg2 = reinterpret_cast< wxWindow * >(argp2);
25626 }
25627 {
25628 PyThreadState* __tstate = wxPyBeginAllowThreads();
25629 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25630 wxPyEndAllowThreads(__tstate);
25631 if (PyErr_Occurred()) SWIG_fail;
25632 }
25633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25634 return resultobj;
25635 fail:
25636 return NULL;
25637 }
25638
25639
25640 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25641 PyObject *resultobj = 0;
25642 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25643 wxWindow *result = 0 ;
25644 void *argp1 = 0 ;
25645 int res1 = 0 ;
25646 PyObject *swig_obj[1] ;
25647
25648 if (!args) SWIG_fail;
25649 swig_obj[0] = args;
25650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25651 if (!SWIG_IsOK(res1)) {
25652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25653 }
25654 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25655 {
25656 PyThreadState* __tstate = wxPyBeginAllowThreads();
25657 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25658 wxPyEndAllowThreads(__tstate);
25659 if (PyErr_Occurred()) SWIG_fail;
25660 }
25661 {
25662 resultobj = wxPyMake_wxObject(result, (bool)0);
25663 }
25664 return resultobj;
25665 fail:
25666 return NULL;
25667 }
25668
25669
25670 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25671 PyObject *obj;
25672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25673 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25674 return SWIG_Py_Void();
25675 }
25676
25677 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25678 return SWIG_Python_InitShadowInstance(args);
25679 }
25680
25681 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25682 PyObject *resultobj = 0;
25683 int arg1 = (int) 0 ;
25684 wxMouseCaptureLostEvent *result = 0 ;
25685 int val1 ;
25686 int ecode1 = 0 ;
25687 PyObject * obj0 = 0 ;
25688 char * kwnames[] = {
25689 (char *) "winid", NULL
25690 };
25691
25692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25693 if (obj0) {
25694 ecode1 = SWIG_AsVal_int(obj0, &val1);
25695 if (!SWIG_IsOK(ecode1)) {
25696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25697 }
25698 arg1 = static_cast< int >(val1);
25699 }
25700 {
25701 PyThreadState* __tstate = wxPyBeginAllowThreads();
25702 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25703 wxPyEndAllowThreads(__tstate);
25704 if (PyErr_Occurred()) SWIG_fail;
25705 }
25706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25707 return resultobj;
25708 fail:
25709 return NULL;
25710 }
25711
25712
25713 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25714 PyObject *obj;
25715 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25716 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25717 return SWIG_Py_Void();
25718 }
25719
25720 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25721 return SWIG_Python_InitShadowInstance(args);
25722 }
25723
25724 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25725 PyObject *resultobj = 0;
25726 wxDisplayChangedEvent *result = 0 ;
25727
25728 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25729 {
25730 PyThreadState* __tstate = wxPyBeginAllowThreads();
25731 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25732 wxPyEndAllowThreads(__tstate);
25733 if (PyErr_Occurred()) SWIG_fail;
25734 }
25735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25736 return resultobj;
25737 fail:
25738 return NULL;
25739 }
25740
25741
25742 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25743 PyObject *obj;
25744 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25745 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25746 return SWIG_Py_Void();
25747 }
25748
25749 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25750 return SWIG_Python_InitShadowInstance(args);
25751 }
25752
25753 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25754 PyObject *resultobj = 0;
25755 int arg1 = (int) 0 ;
25756 wxPaletteChangedEvent *result = 0 ;
25757 int val1 ;
25758 int ecode1 = 0 ;
25759 PyObject * obj0 = 0 ;
25760 char * kwnames[] = {
25761 (char *) "id", NULL
25762 };
25763
25764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25765 if (obj0) {
25766 ecode1 = SWIG_AsVal_int(obj0, &val1);
25767 if (!SWIG_IsOK(ecode1)) {
25768 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25769 }
25770 arg1 = static_cast< int >(val1);
25771 }
25772 {
25773 PyThreadState* __tstate = wxPyBeginAllowThreads();
25774 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25775 wxPyEndAllowThreads(__tstate);
25776 if (PyErr_Occurred()) SWIG_fail;
25777 }
25778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25779 return resultobj;
25780 fail:
25781 return NULL;
25782 }
25783
25784
25785 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25786 PyObject *resultobj = 0;
25787 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25788 wxWindow *arg2 = (wxWindow *) 0 ;
25789 void *argp1 = 0 ;
25790 int res1 = 0 ;
25791 void *argp2 = 0 ;
25792 int res2 = 0 ;
25793 PyObject * obj0 = 0 ;
25794 PyObject * obj1 = 0 ;
25795 char * kwnames[] = {
25796 (char *) "self",(char *) "win", NULL
25797 };
25798
25799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25801 if (!SWIG_IsOK(res1)) {
25802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25803 }
25804 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25805 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25806 if (!SWIG_IsOK(res2)) {
25807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25808 }
25809 arg2 = reinterpret_cast< wxWindow * >(argp2);
25810 {
25811 PyThreadState* __tstate = wxPyBeginAllowThreads();
25812 (arg1)->SetChangedWindow(arg2);
25813 wxPyEndAllowThreads(__tstate);
25814 if (PyErr_Occurred()) SWIG_fail;
25815 }
25816 resultobj = SWIG_Py_Void();
25817 return resultobj;
25818 fail:
25819 return NULL;
25820 }
25821
25822
25823 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25824 PyObject *resultobj = 0;
25825 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25826 wxWindow *result = 0 ;
25827 void *argp1 = 0 ;
25828 int res1 = 0 ;
25829 PyObject *swig_obj[1] ;
25830
25831 if (!args) SWIG_fail;
25832 swig_obj[0] = args;
25833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25834 if (!SWIG_IsOK(res1)) {
25835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25836 }
25837 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25838 {
25839 PyThreadState* __tstate = wxPyBeginAllowThreads();
25840 result = (wxWindow *)(arg1)->GetChangedWindow();
25841 wxPyEndAllowThreads(__tstate);
25842 if (PyErr_Occurred()) SWIG_fail;
25843 }
25844 {
25845 resultobj = wxPyMake_wxObject(result, (bool)0);
25846 }
25847 return resultobj;
25848 fail:
25849 return NULL;
25850 }
25851
25852
25853 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25854 PyObject *obj;
25855 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25856 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25857 return SWIG_Py_Void();
25858 }
25859
25860 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25861 return SWIG_Python_InitShadowInstance(args);
25862 }
25863
25864 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25865 PyObject *resultobj = 0;
25866 int arg1 = (int) 0 ;
25867 wxQueryNewPaletteEvent *result = 0 ;
25868 int val1 ;
25869 int ecode1 = 0 ;
25870 PyObject * obj0 = 0 ;
25871 char * kwnames[] = {
25872 (char *) "winid", NULL
25873 };
25874
25875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25876 if (obj0) {
25877 ecode1 = SWIG_AsVal_int(obj0, &val1);
25878 if (!SWIG_IsOK(ecode1)) {
25879 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25880 }
25881 arg1 = static_cast< int >(val1);
25882 }
25883 {
25884 PyThreadState* __tstate = wxPyBeginAllowThreads();
25885 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25886 wxPyEndAllowThreads(__tstate);
25887 if (PyErr_Occurred()) SWIG_fail;
25888 }
25889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25890 return resultobj;
25891 fail:
25892 return NULL;
25893 }
25894
25895
25896 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25897 PyObject *resultobj = 0;
25898 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25899 bool arg2 ;
25900 void *argp1 = 0 ;
25901 int res1 = 0 ;
25902 bool val2 ;
25903 int ecode2 = 0 ;
25904 PyObject * obj0 = 0 ;
25905 PyObject * obj1 = 0 ;
25906 char * kwnames[] = {
25907 (char *) "self",(char *) "realized", NULL
25908 };
25909
25910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25912 if (!SWIG_IsOK(res1)) {
25913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25914 }
25915 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25916 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25917 if (!SWIG_IsOK(ecode2)) {
25918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25919 }
25920 arg2 = static_cast< bool >(val2);
25921 {
25922 PyThreadState* __tstate = wxPyBeginAllowThreads();
25923 (arg1)->SetPaletteRealized(arg2);
25924 wxPyEndAllowThreads(__tstate);
25925 if (PyErr_Occurred()) SWIG_fail;
25926 }
25927 resultobj = SWIG_Py_Void();
25928 return resultobj;
25929 fail:
25930 return NULL;
25931 }
25932
25933
25934 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25935 PyObject *resultobj = 0;
25936 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25937 bool result;
25938 void *argp1 = 0 ;
25939 int res1 = 0 ;
25940 PyObject *swig_obj[1] ;
25941
25942 if (!args) SWIG_fail;
25943 swig_obj[0] = args;
25944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25945 if (!SWIG_IsOK(res1)) {
25946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25947 }
25948 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25949 {
25950 PyThreadState* __tstate = wxPyBeginAllowThreads();
25951 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25952 wxPyEndAllowThreads(__tstate);
25953 if (PyErr_Occurred()) SWIG_fail;
25954 }
25955 {
25956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25957 }
25958 return resultobj;
25959 fail:
25960 return NULL;
25961 }
25962
25963
25964 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25965 PyObject *obj;
25966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25967 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25968 return SWIG_Py_Void();
25969 }
25970
25971 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25972 return SWIG_Python_InitShadowInstance(args);
25973 }
25974
25975 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25976 PyObject *resultobj = 0;
25977 wxNavigationKeyEvent *result = 0 ;
25978
25979 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25980 {
25981 PyThreadState* __tstate = wxPyBeginAllowThreads();
25982 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25983 wxPyEndAllowThreads(__tstate);
25984 if (PyErr_Occurred()) SWIG_fail;
25985 }
25986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25987 return resultobj;
25988 fail:
25989 return NULL;
25990 }
25991
25992
25993 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25994 PyObject *resultobj = 0;
25995 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25996 bool result;
25997 void *argp1 = 0 ;
25998 int res1 = 0 ;
25999 PyObject *swig_obj[1] ;
26000
26001 if (!args) SWIG_fail;
26002 swig_obj[0] = args;
26003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26004 if (!SWIG_IsOK(res1)) {
26005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26006 }
26007 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26008 {
26009 PyThreadState* __tstate = wxPyBeginAllowThreads();
26010 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26011 wxPyEndAllowThreads(__tstate);
26012 if (PyErr_Occurred()) SWIG_fail;
26013 }
26014 {
26015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26016 }
26017 return resultobj;
26018 fail:
26019 return NULL;
26020 }
26021
26022
26023 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26024 PyObject *resultobj = 0;
26025 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26026 bool arg2 ;
26027 void *argp1 = 0 ;
26028 int res1 = 0 ;
26029 bool val2 ;
26030 int ecode2 = 0 ;
26031 PyObject * obj0 = 0 ;
26032 PyObject * obj1 = 0 ;
26033 char * kwnames[] = {
26034 (char *) "self",(char *) "forward", NULL
26035 };
26036
26037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26039 if (!SWIG_IsOK(res1)) {
26040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26041 }
26042 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26043 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26044 if (!SWIG_IsOK(ecode2)) {
26045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26046 }
26047 arg2 = static_cast< bool >(val2);
26048 {
26049 PyThreadState* __tstate = wxPyBeginAllowThreads();
26050 (arg1)->SetDirection(arg2);
26051 wxPyEndAllowThreads(__tstate);
26052 if (PyErr_Occurred()) SWIG_fail;
26053 }
26054 resultobj = SWIG_Py_Void();
26055 return resultobj;
26056 fail:
26057 return NULL;
26058 }
26059
26060
26061 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26062 PyObject *resultobj = 0;
26063 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26064 bool result;
26065 void *argp1 = 0 ;
26066 int res1 = 0 ;
26067 PyObject *swig_obj[1] ;
26068
26069 if (!args) SWIG_fail;
26070 swig_obj[0] = args;
26071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26072 if (!SWIG_IsOK(res1)) {
26073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26074 }
26075 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26076 {
26077 PyThreadState* __tstate = wxPyBeginAllowThreads();
26078 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26079 wxPyEndAllowThreads(__tstate);
26080 if (PyErr_Occurred()) SWIG_fail;
26081 }
26082 {
26083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26084 }
26085 return resultobj;
26086 fail:
26087 return NULL;
26088 }
26089
26090
26091 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26092 PyObject *resultobj = 0;
26093 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26094 bool arg2 ;
26095 void *argp1 = 0 ;
26096 int res1 = 0 ;
26097 bool val2 ;
26098 int ecode2 = 0 ;
26099 PyObject * obj0 = 0 ;
26100 PyObject * obj1 = 0 ;
26101 char * kwnames[] = {
26102 (char *) "self",(char *) "ischange", NULL
26103 };
26104
26105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26107 if (!SWIG_IsOK(res1)) {
26108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26109 }
26110 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26111 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26112 if (!SWIG_IsOK(ecode2)) {
26113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26114 }
26115 arg2 = static_cast< bool >(val2);
26116 {
26117 PyThreadState* __tstate = wxPyBeginAllowThreads();
26118 (arg1)->SetWindowChange(arg2);
26119 wxPyEndAllowThreads(__tstate);
26120 if (PyErr_Occurred()) SWIG_fail;
26121 }
26122 resultobj = SWIG_Py_Void();
26123 return resultobj;
26124 fail:
26125 return NULL;
26126 }
26127
26128
26129 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26130 PyObject *resultobj = 0;
26131 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26132 bool result;
26133 void *argp1 = 0 ;
26134 int res1 = 0 ;
26135 PyObject *swig_obj[1] ;
26136
26137 if (!args) SWIG_fail;
26138 swig_obj[0] = args;
26139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26140 if (!SWIG_IsOK(res1)) {
26141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26142 }
26143 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26144 {
26145 PyThreadState* __tstate = wxPyBeginAllowThreads();
26146 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26147 wxPyEndAllowThreads(__tstate);
26148 if (PyErr_Occurred()) SWIG_fail;
26149 }
26150 {
26151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26152 }
26153 return resultobj;
26154 fail:
26155 return NULL;
26156 }
26157
26158
26159 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26160 PyObject *resultobj = 0;
26161 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26162 bool arg2 ;
26163 void *argp1 = 0 ;
26164 int res1 = 0 ;
26165 bool val2 ;
26166 int ecode2 = 0 ;
26167 PyObject * obj0 = 0 ;
26168 PyObject * obj1 = 0 ;
26169 char * kwnames[] = {
26170 (char *) "self",(char *) "bIs", NULL
26171 };
26172
26173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26175 if (!SWIG_IsOK(res1)) {
26176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26177 }
26178 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26179 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26180 if (!SWIG_IsOK(ecode2)) {
26181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26182 }
26183 arg2 = static_cast< bool >(val2);
26184 {
26185 PyThreadState* __tstate = wxPyBeginAllowThreads();
26186 (arg1)->SetFromTab(arg2);
26187 wxPyEndAllowThreads(__tstate);
26188 if (PyErr_Occurred()) SWIG_fail;
26189 }
26190 resultobj = SWIG_Py_Void();
26191 return resultobj;
26192 fail:
26193 return NULL;
26194 }
26195
26196
26197 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26198 PyObject *resultobj = 0;
26199 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26200 long arg2 ;
26201 void *argp1 = 0 ;
26202 int res1 = 0 ;
26203 long val2 ;
26204 int ecode2 = 0 ;
26205 PyObject * obj0 = 0 ;
26206 PyObject * obj1 = 0 ;
26207 char * kwnames[] = {
26208 (char *) "self",(char *) "flags", NULL
26209 };
26210
26211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26213 if (!SWIG_IsOK(res1)) {
26214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26215 }
26216 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26217 ecode2 = SWIG_AsVal_long(obj1, &val2);
26218 if (!SWIG_IsOK(ecode2)) {
26219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26220 }
26221 arg2 = static_cast< long >(val2);
26222 {
26223 PyThreadState* __tstate = wxPyBeginAllowThreads();
26224 (arg1)->SetFlags(arg2);
26225 wxPyEndAllowThreads(__tstate);
26226 if (PyErr_Occurred()) SWIG_fail;
26227 }
26228 resultobj = SWIG_Py_Void();
26229 return resultobj;
26230 fail:
26231 return NULL;
26232 }
26233
26234
26235 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26236 PyObject *resultobj = 0;
26237 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26238 wxWindow *result = 0 ;
26239 void *argp1 = 0 ;
26240 int res1 = 0 ;
26241 PyObject *swig_obj[1] ;
26242
26243 if (!args) SWIG_fail;
26244 swig_obj[0] = args;
26245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26246 if (!SWIG_IsOK(res1)) {
26247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26248 }
26249 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26250 {
26251 PyThreadState* __tstate = wxPyBeginAllowThreads();
26252 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26253 wxPyEndAllowThreads(__tstate);
26254 if (PyErr_Occurred()) SWIG_fail;
26255 }
26256 {
26257 resultobj = wxPyMake_wxObject(result, (bool)0);
26258 }
26259 return resultobj;
26260 fail:
26261 return NULL;
26262 }
26263
26264
26265 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26266 PyObject *resultobj = 0;
26267 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26268 wxWindow *arg2 = (wxWindow *) 0 ;
26269 void *argp1 = 0 ;
26270 int res1 = 0 ;
26271 void *argp2 = 0 ;
26272 int res2 = 0 ;
26273 PyObject * obj0 = 0 ;
26274 PyObject * obj1 = 0 ;
26275 char * kwnames[] = {
26276 (char *) "self",(char *) "win", NULL
26277 };
26278
26279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26281 if (!SWIG_IsOK(res1)) {
26282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26283 }
26284 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26285 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26286 if (!SWIG_IsOK(res2)) {
26287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26288 }
26289 arg2 = reinterpret_cast< wxWindow * >(argp2);
26290 {
26291 PyThreadState* __tstate = wxPyBeginAllowThreads();
26292 (arg1)->SetCurrentFocus(arg2);
26293 wxPyEndAllowThreads(__tstate);
26294 if (PyErr_Occurred()) SWIG_fail;
26295 }
26296 resultobj = SWIG_Py_Void();
26297 return resultobj;
26298 fail:
26299 return NULL;
26300 }
26301
26302
26303 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26304 PyObject *obj;
26305 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26306 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26307 return SWIG_Py_Void();
26308 }
26309
26310 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26311 return SWIG_Python_InitShadowInstance(args);
26312 }
26313
26314 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26315 PyObject *resultobj = 0;
26316 wxWindow *arg1 = (wxWindow *) NULL ;
26317 wxWindowCreateEvent *result = 0 ;
26318 void *argp1 = 0 ;
26319 int res1 = 0 ;
26320 PyObject * obj0 = 0 ;
26321 char * kwnames[] = {
26322 (char *) "win", NULL
26323 };
26324
26325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26326 if (obj0) {
26327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26328 if (!SWIG_IsOK(res1)) {
26329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26330 }
26331 arg1 = reinterpret_cast< wxWindow * >(argp1);
26332 }
26333 {
26334 PyThreadState* __tstate = wxPyBeginAllowThreads();
26335 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26336 wxPyEndAllowThreads(__tstate);
26337 if (PyErr_Occurred()) SWIG_fail;
26338 }
26339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26340 return resultobj;
26341 fail:
26342 return NULL;
26343 }
26344
26345
26346 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26347 PyObject *resultobj = 0;
26348 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26349 wxWindow *result = 0 ;
26350 void *argp1 = 0 ;
26351 int res1 = 0 ;
26352 PyObject *swig_obj[1] ;
26353
26354 if (!args) SWIG_fail;
26355 swig_obj[0] = args;
26356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26357 if (!SWIG_IsOK(res1)) {
26358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26359 }
26360 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26361 {
26362 PyThreadState* __tstate = wxPyBeginAllowThreads();
26363 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26364 wxPyEndAllowThreads(__tstate);
26365 if (PyErr_Occurred()) SWIG_fail;
26366 }
26367 {
26368 resultobj = wxPyMake_wxObject(result, (bool)0);
26369 }
26370 return resultobj;
26371 fail:
26372 return NULL;
26373 }
26374
26375
26376 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26377 PyObject *obj;
26378 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26379 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26380 return SWIG_Py_Void();
26381 }
26382
26383 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26384 return SWIG_Python_InitShadowInstance(args);
26385 }
26386
26387 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26388 PyObject *resultobj = 0;
26389 wxWindow *arg1 = (wxWindow *) NULL ;
26390 wxWindowDestroyEvent *result = 0 ;
26391 void *argp1 = 0 ;
26392 int res1 = 0 ;
26393 PyObject * obj0 = 0 ;
26394 char * kwnames[] = {
26395 (char *) "win", NULL
26396 };
26397
26398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26399 if (obj0) {
26400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26401 if (!SWIG_IsOK(res1)) {
26402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26403 }
26404 arg1 = reinterpret_cast< wxWindow * >(argp1);
26405 }
26406 {
26407 PyThreadState* __tstate = wxPyBeginAllowThreads();
26408 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26409 wxPyEndAllowThreads(__tstate);
26410 if (PyErr_Occurred()) SWIG_fail;
26411 }
26412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26413 return resultobj;
26414 fail:
26415 return NULL;
26416 }
26417
26418
26419 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26420 PyObject *resultobj = 0;
26421 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26422 wxWindow *result = 0 ;
26423 void *argp1 = 0 ;
26424 int res1 = 0 ;
26425 PyObject *swig_obj[1] ;
26426
26427 if (!args) SWIG_fail;
26428 swig_obj[0] = args;
26429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26430 if (!SWIG_IsOK(res1)) {
26431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26432 }
26433 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26434 {
26435 PyThreadState* __tstate = wxPyBeginAllowThreads();
26436 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26437 wxPyEndAllowThreads(__tstate);
26438 if (PyErr_Occurred()) SWIG_fail;
26439 }
26440 {
26441 resultobj = wxPyMake_wxObject(result, (bool)0);
26442 }
26443 return resultobj;
26444 fail:
26445 return NULL;
26446 }
26447
26448
26449 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26450 PyObject *obj;
26451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26452 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26453 return SWIG_Py_Void();
26454 }
26455
26456 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26457 return SWIG_Python_InitShadowInstance(args);
26458 }
26459
26460 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26461 PyObject *resultobj = 0;
26462 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26463 int arg2 = (int) 0 ;
26464 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26465 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26466 wxContextMenuEvent *result = 0 ;
26467 int val1 ;
26468 int ecode1 = 0 ;
26469 int val2 ;
26470 int ecode2 = 0 ;
26471 wxPoint temp3 ;
26472 PyObject * obj0 = 0 ;
26473 PyObject * obj1 = 0 ;
26474 PyObject * obj2 = 0 ;
26475 char * kwnames[] = {
26476 (char *) "type",(char *) "winid",(char *) "pt", NULL
26477 };
26478
26479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26480 if (obj0) {
26481 ecode1 = SWIG_AsVal_int(obj0, &val1);
26482 if (!SWIG_IsOK(ecode1)) {
26483 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26484 }
26485 arg1 = static_cast< wxEventType >(val1);
26486 }
26487 if (obj1) {
26488 ecode2 = SWIG_AsVal_int(obj1, &val2);
26489 if (!SWIG_IsOK(ecode2)) {
26490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26491 }
26492 arg2 = static_cast< int >(val2);
26493 }
26494 if (obj2) {
26495 {
26496 arg3 = &temp3;
26497 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26498 }
26499 }
26500 {
26501 PyThreadState* __tstate = wxPyBeginAllowThreads();
26502 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26503 wxPyEndAllowThreads(__tstate);
26504 if (PyErr_Occurred()) SWIG_fail;
26505 }
26506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26507 return resultobj;
26508 fail:
26509 return NULL;
26510 }
26511
26512
26513 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26514 PyObject *resultobj = 0;
26515 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26516 wxPoint *result = 0 ;
26517 void *argp1 = 0 ;
26518 int res1 = 0 ;
26519 PyObject *swig_obj[1] ;
26520
26521 if (!args) SWIG_fail;
26522 swig_obj[0] = args;
26523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26524 if (!SWIG_IsOK(res1)) {
26525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26526 }
26527 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26528 {
26529 PyThreadState* __tstate = wxPyBeginAllowThreads();
26530 {
26531 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26532 result = (wxPoint *) &_result_ref;
26533 }
26534 wxPyEndAllowThreads(__tstate);
26535 if (PyErr_Occurred()) SWIG_fail;
26536 }
26537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26538 return resultobj;
26539 fail:
26540 return NULL;
26541 }
26542
26543
26544 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26545 PyObject *resultobj = 0;
26546 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26547 wxPoint *arg2 = 0 ;
26548 void *argp1 = 0 ;
26549 int res1 = 0 ;
26550 wxPoint temp2 ;
26551 PyObject * obj0 = 0 ;
26552 PyObject * obj1 = 0 ;
26553 char * kwnames[] = {
26554 (char *) "self",(char *) "pos", NULL
26555 };
26556
26557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26559 if (!SWIG_IsOK(res1)) {
26560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26561 }
26562 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26563 {
26564 arg2 = &temp2;
26565 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26566 }
26567 {
26568 PyThreadState* __tstate = wxPyBeginAllowThreads();
26569 (arg1)->SetPosition((wxPoint const &)*arg2);
26570 wxPyEndAllowThreads(__tstate);
26571 if (PyErr_Occurred()) SWIG_fail;
26572 }
26573 resultobj = SWIG_Py_Void();
26574 return resultobj;
26575 fail:
26576 return NULL;
26577 }
26578
26579
26580 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26581 PyObject *obj;
26582 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26583 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26584 return SWIG_Py_Void();
26585 }
26586
26587 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26588 return SWIG_Python_InitShadowInstance(args);
26589 }
26590
26591 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26592 PyObject *resultobj = 0;
26593 wxIdleEvent *result = 0 ;
26594
26595 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26596 {
26597 PyThreadState* __tstate = wxPyBeginAllowThreads();
26598 result = (wxIdleEvent *)new wxIdleEvent();
26599 wxPyEndAllowThreads(__tstate);
26600 if (PyErr_Occurred()) SWIG_fail;
26601 }
26602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26603 return resultobj;
26604 fail:
26605 return NULL;
26606 }
26607
26608
26609 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26610 PyObject *resultobj = 0;
26611 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26612 bool arg2 = (bool) true ;
26613 void *argp1 = 0 ;
26614 int res1 = 0 ;
26615 bool val2 ;
26616 int ecode2 = 0 ;
26617 PyObject * obj0 = 0 ;
26618 PyObject * obj1 = 0 ;
26619 char * kwnames[] = {
26620 (char *) "self",(char *) "needMore", NULL
26621 };
26622
26623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26625 if (!SWIG_IsOK(res1)) {
26626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26627 }
26628 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26629 if (obj1) {
26630 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26631 if (!SWIG_IsOK(ecode2)) {
26632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26633 }
26634 arg2 = static_cast< bool >(val2);
26635 }
26636 {
26637 PyThreadState* __tstate = wxPyBeginAllowThreads();
26638 (arg1)->RequestMore(arg2);
26639 wxPyEndAllowThreads(__tstate);
26640 if (PyErr_Occurred()) SWIG_fail;
26641 }
26642 resultobj = SWIG_Py_Void();
26643 return resultobj;
26644 fail:
26645 return NULL;
26646 }
26647
26648
26649 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26650 PyObject *resultobj = 0;
26651 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26652 bool result;
26653 void *argp1 = 0 ;
26654 int res1 = 0 ;
26655 PyObject *swig_obj[1] ;
26656
26657 if (!args) SWIG_fail;
26658 swig_obj[0] = args;
26659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26660 if (!SWIG_IsOK(res1)) {
26661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26662 }
26663 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26664 {
26665 PyThreadState* __tstate = wxPyBeginAllowThreads();
26666 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26667 wxPyEndAllowThreads(__tstate);
26668 if (PyErr_Occurred()) SWIG_fail;
26669 }
26670 {
26671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26672 }
26673 return resultobj;
26674 fail:
26675 return NULL;
26676 }
26677
26678
26679 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26680 PyObject *resultobj = 0;
26681 wxIdleMode arg1 ;
26682 int val1 ;
26683 int ecode1 = 0 ;
26684 PyObject * obj0 = 0 ;
26685 char * kwnames[] = {
26686 (char *) "mode", NULL
26687 };
26688
26689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26690 ecode1 = SWIG_AsVal_int(obj0, &val1);
26691 if (!SWIG_IsOK(ecode1)) {
26692 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26693 }
26694 arg1 = static_cast< wxIdleMode >(val1);
26695 {
26696 PyThreadState* __tstate = wxPyBeginAllowThreads();
26697 wxIdleEvent::SetMode(arg1);
26698 wxPyEndAllowThreads(__tstate);
26699 if (PyErr_Occurred()) SWIG_fail;
26700 }
26701 resultobj = SWIG_Py_Void();
26702 return resultobj;
26703 fail:
26704 return NULL;
26705 }
26706
26707
26708 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26709 PyObject *resultobj = 0;
26710 wxIdleMode result;
26711
26712 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26713 {
26714 PyThreadState* __tstate = wxPyBeginAllowThreads();
26715 result = (wxIdleMode)wxIdleEvent::GetMode();
26716 wxPyEndAllowThreads(__tstate);
26717 if (PyErr_Occurred()) SWIG_fail;
26718 }
26719 resultobj = SWIG_From_int(static_cast< int >(result));
26720 return resultobj;
26721 fail:
26722 return NULL;
26723 }
26724
26725
26726 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26727 PyObject *resultobj = 0;
26728 wxWindow *arg1 = (wxWindow *) 0 ;
26729 bool result;
26730 void *argp1 = 0 ;
26731 int res1 = 0 ;
26732 PyObject * obj0 = 0 ;
26733 char * kwnames[] = {
26734 (char *) "win", NULL
26735 };
26736
26737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26739 if (!SWIG_IsOK(res1)) {
26740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26741 }
26742 arg1 = reinterpret_cast< wxWindow * >(argp1);
26743 {
26744 PyThreadState* __tstate = wxPyBeginAllowThreads();
26745 result = (bool)wxIdleEvent::CanSend(arg1);
26746 wxPyEndAllowThreads(__tstate);
26747 if (PyErr_Occurred()) SWIG_fail;
26748 }
26749 {
26750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26751 }
26752 return resultobj;
26753 fail:
26754 return NULL;
26755 }
26756
26757
26758 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26759 PyObject *obj;
26760 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26761 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26762 return SWIG_Py_Void();
26763 }
26764
26765 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26766 return SWIG_Python_InitShadowInstance(args);
26767 }
26768
26769 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26770 PyObject *resultobj = 0;
26771 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26772 int arg2 = (int) 0 ;
26773 wxClipboardTextEvent *result = 0 ;
26774 int val1 ;
26775 int ecode1 = 0 ;
26776 int val2 ;
26777 int ecode2 = 0 ;
26778 PyObject * obj0 = 0 ;
26779 PyObject * obj1 = 0 ;
26780 char * kwnames[] = {
26781 (char *) "type",(char *) "winid", NULL
26782 };
26783
26784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26785 if (obj0) {
26786 ecode1 = SWIG_AsVal_int(obj0, &val1);
26787 if (!SWIG_IsOK(ecode1)) {
26788 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26789 }
26790 arg1 = static_cast< wxEventType >(val1);
26791 }
26792 if (obj1) {
26793 ecode2 = SWIG_AsVal_int(obj1, &val2);
26794 if (!SWIG_IsOK(ecode2)) {
26795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26796 }
26797 arg2 = static_cast< int >(val2);
26798 }
26799 {
26800 PyThreadState* __tstate = wxPyBeginAllowThreads();
26801 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26802 wxPyEndAllowThreads(__tstate);
26803 if (PyErr_Occurred()) SWIG_fail;
26804 }
26805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26806 return resultobj;
26807 fail:
26808 return NULL;
26809 }
26810
26811
26812 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26813 PyObject *obj;
26814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26815 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26816 return SWIG_Py_Void();
26817 }
26818
26819 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26820 return SWIG_Python_InitShadowInstance(args);
26821 }
26822
26823 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26824 PyObject *resultobj = 0;
26825 int arg1 = (int) 0 ;
26826 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26827 wxPyEvent *result = 0 ;
26828 int val1 ;
26829 int ecode1 = 0 ;
26830 int val2 ;
26831 int ecode2 = 0 ;
26832 PyObject * obj0 = 0 ;
26833 PyObject * obj1 = 0 ;
26834 char * kwnames[] = {
26835 (char *) "winid",(char *) "eventType", NULL
26836 };
26837
26838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26839 if (obj0) {
26840 ecode1 = SWIG_AsVal_int(obj0, &val1);
26841 if (!SWIG_IsOK(ecode1)) {
26842 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26843 }
26844 arg1 = static_cast< int >(val1);
26845 }
26846 if (obj1) {
26847 ecode2 = SWIG_AsVal_int(obj1, &val2);
26848 if (!SWIG_IsOK(ecode2)) {
26849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26850 }
26851 arg2 = static_cast< wxEventType >(val2);
26852 }
26853 {
26854 PyThreadState* __tstate = wxPyBeginAllowThreads();
26855 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26856 wxPyEndAllowThreads(__tstate);
26857 if (PyErr_Occurred()) SWIG_fail;
26858 }
26859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26860 return resultobj;
26861 fail:
26862 return NULL;
26863 }
26864
26865
26866 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26867 PyObject *resultobj = 0;
26868 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26869 void *argp1 = 0 ;
26870 int res1 = 0 ;
26871 PyObject *swig_obj[1] ;
26872
26873 if (!args) SWIG_fail;
26874 swig_obj[0] = args;
26875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26876 if (!SWIG_IsOK(res1)) {
26877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26878 }
26879 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26880 {
26881 PyThreadState* __tstate = wxPyBeginAllowThreads();
26882 delete arg1;
26883
26884 wxPyEndAllowThreads(__tstate);
26885 if (PyErr_Occurred()) SWIG_fail;
26886 }
26887 resultobj = SWIG_Py_Void();
26888 return resultobj;
26889 fail:
26890 return NULL;
26891 }
26892
26893
26894 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26895 PyObject *resultobj = 0;
26896 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26897 PyObject *arg2 = (PyObject *) 0 ;
26898 void *argp1 = 0 ;
26899 int res1 = 0 ;
26900 PyObject * obj0 = 0 ;
26901 PyObject * obj1 = 0 ;
26902 char * kwnames[] = {
26903 (char *) "self",(char *) "self", NULL
26904 };
26905
26906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26908 if (!SWIG_IsOK(res1)) {
26909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26910 }
26911 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26912 arg2 = obj1;
26913 {
26914 PyThreadState* __tstate = wxPyBeginAllowThreads();
26915 (arg1)->SetSelf(arg2);
26916 wxPyEndAllowThreads(__tstate);
26917 if (PyErr_Occurred()) SWIG_fail;
26918 }
26919 resultobj = SWIG_Py_Void();
26920 return resultobj;
26921 fail:
26922 return NULL;
26923 }
26924
26925
26926 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26927 PyObject *resultobj = 0;
26928 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26929 PyObject *result = 0 ;
26930 void *argp1 = 0 ;
26931 int res1 = 0 ;
26932 PyObject *swig_obj[1] ;
26933
26934 if (!args) SWIG_fail;
26935 swig_obj[0] = args;
26936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26937 if (!SWIG_IsOK(res1)) {
26938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26939 }
26940 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26941 {
26942 PyThreadState* __tstate = wxPyBeginAllowThreads();
26943 result = (PyObject *)(arg1)->GetSelf();
26944 wxPyEndAllowThreads(__tstate);
26945 if (PyErr_Occurred()) SWIG_fail;
26946 }
26947 resultobj = result;
26948 return resultobj;
26949 fail:
26950 return NULL;
26951 }
26952
26953
26954 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26955 PyObject *obj;
26956 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26957 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26958 return SWIG_Py_Void();
26959 }
26960
26961 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26962 return SWIG_Python_InitShadowInstance(args);
26963 }
26964
26965 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26966 PyObject *resultobj = 0;
26967 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26968 int arg2 = (int) 0 ;
26969 wxPyCommandEvent *result = 0 ;
26970 int val1 ;
26971 int ecode1 = 0 ;
26972 int val2 ;
26973 int ecode2 = 0 ;
26974 PyObject * obj0 = 0 ;
26975 PyObject * obj1 = 0 ;
26976 char * kwnames[] = {
26977 (char *) "eventType",(char *) "id", NULL
26978 };
26979
26980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26981 if (obj0) {
26982 ecode1 = SWIG_AsVal_int(obj0, &val1);
26983 if (!SWIG_IsOK(ecode1)) {
26984 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26985 }
26986 arg1 = static_cast< wxEventType >(val1);
26987 }
26988 if (obj1) {
26989 ecode2 = SWIG_AsVal_int(obj1, &val2);
26990 if (!SWIG_IsOK(ecode2)) {
26991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26992 }
26993 arg2 = static_cast< int >(val2);
26994 }
26995 {
26996 PyThreadState* __tstate = wxPyBeginAllowThreads();
26997 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26998 wxPyEndAllowThreads(__tstate);
26999 if (PyErr_Occurred()) SWIG_fail;
27000 }
27001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27002 return resultobj;
27003 fail:
27004 return NULL;
27005 }
27006
27007
27008 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27009 PyObject *resultobj = 0;
27010 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27011 void *argp1 = 0 ;
27012 int res1 = 0 ;
27013 PyObject *swig_obj[1] ;
27014
27015 if (!args) SWIG_fail;
27016 swig_obj[0] = args;
27017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27018 if (!SWIG_IsOK(res1)) {
27019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27020 }
27021 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27022 {
27023 PyThreadState* __tstate = wxPyBeginAllowThreads();
27024 delete arg1;
27025
27026 wxPyEndAllowThreads(__tstate);
27027 if (PyErr_Occurred()) SWIG_fail;
27028 }
27029 resultobj = SWIG_Py_Void();
27030 return resultobj;
27031 fail:
27032 return NULL;
27033 }
27034
27035
27036 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27037 PyObject *resultobj = 0;
27038 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27039 PyObject *arg2 = (PyObject *) 0 ;
27040 void *argp1 = 0 ;
27041 int res1 = 0 ;
27042 PyObject * obj0 = 0 ;
27043 PyObject * obj1 = 0 ;
27044 char * kwnames[] = {
27045 (char *) "self",(char *) "self", NULL
27046 };
27047
27048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27050 if (!SWIG_IsOK(res1)) {
27051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27052 }
27053 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27054 arg2 = obj1;
27055 {
27056 PyThreadState* __tstate = wxPyBeginAllowThreads();
27057 (arg1)->SetSelf(arg2);
27058 wxPyEndAllowThreads(__tstate);
27059 if (PyErr_Occurred()) SWIG_fail;
27060 }
27061 resultobj = SWIG_Py_Void();
27062 return resultobj;
27063 fail:
27064 return NULL;
27065 }
27066
27067
27068 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27069 PyObject *resultobj = 0;
27070 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27071 PyObject *result = 0 ;
27072 void *argp1 = 0 ;
27073 int res1 = 0 ;
27074 PyObject *swig_obj[1] ;
27075
27076 if (!args) SWIG_fail;
27077 swig_obj[0] = args;
27078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27079 if (!SWIG_IsOK(res1)) {
27080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27081 }
27082 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27083 {
27084 PyThreadState* __tstate = wxPyBeginAllowThreads();
27085 result = (PyObject *)(arg1)->GetSelf();
27086 wxPyEndAllowThreads(__tstate);
27087 if (PyErr_Occurred()) SWIG_fail;
27088 }
27089 resultobj = result;
27090 return resultobj;
27091 fail:
27092 return NULL;
27093 }
27094
27095
27096 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27097 PyObject *obj;
27098 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27099 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27100 return SWIG_Py_Void();
27101 }
27102
27103 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27104 return SWIG_Python_InitShadowInstance(args);
27105 }
27106
27107 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27108 PyObject *resultobj = 0;
27109 wxWindow *arg1 = (wxWindow *) 0 ;
27110 wxDateTime *arg2 = 0 ;
27111 wxEventType arg3 ;
27112 wxDateEvent *result = 0 ;
27113 void *argp1 = 0 ;
27114 int res1 = 0 ;
27115 void *argp2 = 0 ;
27116 int res2 = 0 ;
27117 int val3 ;
27118 int ecode3 = 0 ;
27119 PyObject * obj0 = 0 ;
27120 PyObject * obj1 = 0 ;
27121 PyObject * obj2 = 0 ;
27122 char * kwnames[] = {
27123 (char *) "win",(char *) "dt",(char *) "type", NULL
27124 };
27125
27126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27128 if (!SWIG_IsOK(res1)) {
27129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27130 }
27131 arg1 = reinterpret_cast< wxWindow * >(argp1);
27132 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27133 if (!SWIG_IsOK(res2)) {
27134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27135 }
27136 if (!argp2) {
27137 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27138 }
27139 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27140 ecode3 = SWIG_AsVal_int(obj2, &val3);
27141 if (!SWIG_IsOK(ecode3)) {
27142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27143 }
27144 arg3 = static_cast< wxEventType >(val3);
27145 {
27146 PyThreadState* __tstate = wxPyBeginAllowThreads();
27147 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27148 wxPyEndAllowThreads(__tstate);
27149 if (PyErr_Occurred()) SWIG_fail;
27150 }
27151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27152 return resultobj;
27153 fail:
27154 return NULL;
27155 }
27156
27157
27158 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27159 PyObject *resultobj = 0;
27160 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27161 wxDateTime *result = 0 ;
27162 void *argp1 = 0 ;
27163 int res1 = 0 ;
27164 PyObject *swig_obj[1] ;
27165
27166 if (!args) SWIG_fail;
27167 swig_obj[0] = args;
27168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27169 if (!SWIG_IsOK(res1)) {
27170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27171 }
27172 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27173 {
27174 PyThreadState* __tstate = wxPyBeginAllowThreads();
27175 {
27176 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27177 result = (wxDateTime *) &_result_ref;
27178 }
27179 wxPyEndAllowThreads(__tstate);
27180 if (PyErr_Occurred()) SWIG_fail;
27181 }
27182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27183 return resultobj;
27184 fail:
27185 return NULL;
27186 }
27187
27188
27189 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27190 PyObject *resultobj = 0;
27191 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27192 wxDateTime *arg2 = 0 ;
27193 void *argp1 = 0 ;
27194 int res1 = 0 ;
27195 void *argp2 = 0 ;
27196 int res2 = 0 ;
27197 PyObject * obj0 = 0 ;
27198 PyObject * obj1 = 0 ;
27199 char * kwnames[] = {
27200 (char *) "self",(char *) "date", NULL
27201 };
27202
27203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27205 if (!SWIG_IsOK(res1)) {
27206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27207 }
27208 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27209 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27210 if (!SWIG_IsOK(res2)) {
27211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27212 }
27213 if (!argp2) {
27214 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27215 }
27216 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27217 {
27218 PyThreadState* __tstate = wxPyBeginAllowThreads();
27219 (arg1)->SetDate((wxDateTime const &)*arg2);
27220 wxPyEndAllowThreads(__tstate);
27221 if (PyErr_Occurred()) SWIG_fail;
27222 }
27223 resultobj = SWIG_Py_Void();
27224 return resultobj;
27225 fail:
27226 return NULL;
27227 }
27228
27229
27230 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27231 PyObject *obj;
27232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27233 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27234 return SWIG_Py_Void();
27235 }
27236
27237 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27238 return SWIG_Python_InitShadowInstance(args);
27239 }
27240
27241 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27242 PyObject *resultobj = 0;
27243 wxPyApp *result = 0 ;
27244
27245 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27246 {
27247 PyThreadState* __tstate = wxPyBeginAllowThreads();
27248 result = (wxPyApp *)new_wxPyApp();
27249 wxPyEndAllowThreads(__tstate);
27250 if (PyErr_Occurred()) SWIG_fail;
27251 }
27252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27253 return resultobj;
27254 fail:
27255 return NULL;
27256 }
27257
27258
27259 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27260 PyObject *resultobj = 0;
27261 wxPyApp *arg1 = (wxPyApp *) 0 ;
27262 void *argp1 = 0 ;
27263 int res1 = 0 ;
27264 PyObject *swig_obj[1] ;
27265
27266 if (!args) SWIG_fail;
27267 swig_obj[0] = args;
27268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27269 if (!SWIG_IsOK(res1)) {
27270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27271 }
27272 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27273 {
27274 PyThreadState* __tstate = wxPyBeginAllowThreads();
27275 delete arg1;
27276
27277 wxPyEndAllowThreads(__tstate);
27278 if (PyErr_Occurred()) SWIG_fail;
27279 }
27280 resultobj = SWIG_Py_Void();
27281 return resultobj;
27282 fail:
27283 return NULL;
27284 }
27285
27286
27287 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27288 PyObject *resultobj = 0;
27289 wxPyApp *arg1 = (wxPyApp *) 0 ;
27290 PyObject *arg2 = (PyObject *) 0 ;
27291 PyObject *arg3 = (PyObject *) 0 ;
27292 bool arg4 ;
27293 void *argp1 = 0 ;
27294 int res1 = 0 ;
27295 bool val4 ;
27296 int ecode4 = 0 ;
27297 PyObject * obj0 = 0 ;
27298 PyObject * obj1 = 0 ;
27299 PyObject * obj2 = 0 ;
27300 PyObject * obj3 = 0 ;
27301 char * kwnames[] = {
27302 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27303 };
27304
27305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27307 if (!SWIG_IsOK(res1)) {
27308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27309 }
27310 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27311 arg2 = obj1;
27312 arg3 = obj2;
27313 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27314 if (!SWIG_IsOK(ecode4)) {
27315 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27316 }
27317 arg4 = static_cast< bool >(val4);
27318 {
27319 PyThreadState* __tstate = wxPyBeginAllowThreads();
27320 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27321 wxPyEndAllowThreads(__tstate);
27322 if (PyErr_Occurred()) SWIG_fail;
27323 }
27324 resultobj = SWIG_Py_Void();
27325 return resultobj;
27326 fail:
27327 return NULL;
27328 }
27329
27330
27331 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27332 PyObject *resultobj = 0;
27333 wxPyApp *arg1 = (wxPyApp *) 0 ;
27334 wxString result;
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_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27344 }
27345 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27346 {
27347 PyThreadState* __tstate = wxPyBeginAllowThreads();
27348 result = ((wxPyApp const *)arg1)->GetAppName();
27349 wxPyEndAllowThreads(__tstate);
27350 if (PyErr_Occurred()) SWIG_fail;
27351 }
27352 {
27353 #if wxUSE_UNICODE
27354 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27355 #else
27356 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27357 #endif
27358 }
27359 return resultobj;
27360 fail:
27361 return NULL;
27362 }
27363
27364
27365 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27366 PyObject *resultobj = 0;
27367 wxPyApp *arg1 = (wxPyApp *) 0 ;
27368 wxString *arg2 = 0 ;
27369 void *argp1 = 0 ;
27370 int res1 = 0 ;
27371 bool temp2 = false ;
27372 PyObject * obj0 = 0 ;
27373 PyObject * obj1 = 0 ;
27374 char * kwnames[] = {
27375 (char *) "self",(char *) "name", NULL
27376 };
27377
27378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27380 if (!SWIG_IsOK(res1)) {
27381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27382 }
27383 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27384 {
27385 arg2 = wxString_in_helper(obj1);
27386 if (arg2 == NULL) SWIG_fail;
27387 temp2 = true;
27388 }
27389 {
27390 PyThreadState* __tstate = wxPyBeginAllowThreads();
27391 (arg1)->SetAppName((wxString const &)*arg2);
27392 wxPyEndAllowThreads(__tstate);
27393 if (PyErr_Occurred()) SWIG_fail;
27394 }
27395 resultobj = SWIG_Py_Void();
27396 {
27397 if (temp2)
27398 delete arg2;
27399 }
27400 return resultobj;
27401 fail:
27402 {
27403 if (temp2)
27404 delete arg2;
27405 }
27406 return NULL;
27407 }
27408
27409
27410 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27411 PyObject *resultobj = 0;
27412 wxPyApp *arg1 = (wxPyApp *) 0 ;
27413 wxString result;
27414 void *argp1 = 0 ;
27415 int res1 = 0 ;
27416 PyObject *swig_obj[1] ;
27417
27418 if (!args) SWIG_fail;
27419 swig_obj[0] = args;
27420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27421 if (!SWIG_IsOK(res1)) {
27422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27423 }
27424 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27425 {
27426 PyThreadState* __tstate = wxPyBeginAllowThreads();
27427 result = ((wxPyApp const *)arg1)->GetClassName();
27428 wxPyEndAllowThreads(__tstate);
27429 if (PyErr_Occurred()) SWIG_fail;
27430 }
27431 {
27432 #if wxUSE_UNICODE
27433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27434 #else
27435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27436 #endif
27437 }
27438 return resultobj;
27439 fail:
27440 return NULL;
27441 }
27442
27443
27444 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27445 PyObject *resultobj = 0;
27446 wxPyApp *arg1 = (wxPyApp *) 0 ;
27447 wxString *arg2 = 0 ;
27448 void *argp1 = 0 ;
27449 int res1 = 0 ;
27450 bool temp2 = false ;
27451 PyObject * obj0 = 0 ;
27452 PyObject * obj1 = 0 ;
27453 char * kwnames[] = {
27454 (char *) "self",(char *) "name", NULL
27455 };
27456
27457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27459 if (!SWIG_IsOK(res1)) {
27460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27461 }
27462 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27463 {
27464 arg2 = wxString_in_helper(obj1);
27465 if (arg2 == NULL) SWIG_fail;
27466 temp2 = true;
27467 }
27468 {
27469 PyThreadState* __tstate = wxPyBeginAllowThreads();
27470 (arg1)->SetClassName((wxString const &)*arg2);
27471 wxPyEndAllowThreads(__tstate);
27472 if (PyErr_Occurred()) SWIG_fail;
27473 }
27474 resultobj = SWIG_Py_Void();
27475 {
27476 if (temp2)
27477 delete arg2;
27478 }
27479 return resultobj;
27480 fail:
27481 {
27482 if (temp2)
27483 delete arg2;
27484 }
27485 return NULL;
27486 }
27487
27488
27489 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27490 PyObject *resultobj = 0;
27491 wxPyApp *arg1 = (wxPyApp *) 0 ;
27492 wxString *result = 0 ;
27493 void *argp1 = 0 ;
27494 int res1 = 0 ;
27495 PyObject *swig_obj[1] ;
27496
27497 if (!args) SWIG_fail;
27498 swig_obj[0] = args;
27499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27500 if (!SWIG_IsOK(res1)) {
27501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27502 }
27503 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27504 {
27505 PyThreadState* __tstate = wxPyBeginAllowThreads();
27506 {
27507 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27508 result = (wxString *) &_result_ref;
27509 }
27510 wxPyEndAllowThreads(__tstate);
27511 if (PyErr_Occurred()) SWIG_fail;
27512 }
27513 {
27514 #if wxUSE_UNICODE
27515 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27516 #else
27517 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27518 #endif
27519 }
27520 return resultobj;
27521 fail:
27522 return NULL;
27523 }
27524
27525
27526 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27527 PyObject *resultobj = 0;
27528 wxPyApp *arg1 = (wxPyApp *) 0 ;
27529 wxString *arg2 = 0 ;
27530 void *argp1 = 0 ;
27531 int res1 = 0 ;
27532 bool temp2 = false ;
27533 PyObject * obj0 = 0 ;
27534 PyObject * obj1 = 0 ;
27535 char * kwnames[] = {
27536 (char *) "self",(char *) "name", NULL
27537 };
27538
27539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27541 if (!SWIG_IsOK(res1)) {
27542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27543 }
27544 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27545 {
27546 arg2 = wxString_in_helper(obj1);
27547 if (arg2 == NULL) SWIG_fail;
27548 temp2 = true;
27549 }
27550 {
27551 PyThreadState* __tstate = wxPyBeginAllowThreads();
27552 (arg1)->SetVendorName((wxString const &)*arg2);
27553 wxPyEndAllowThreads(__tstate);
27554 if (PyErr_Occurred()) SWIG_fail;
27555 }
27556 resultobj = SWIG_Py_Void();
27557 {
27558 if (temp2)
27559 delete arg2;
27560 }
27561 return resultobj;
27562 fail:
27563 {
27564 if (temp2)
27565 delete arg2;
27566 }
27567 return NULL;
27568 }
27569
27570
27571 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27572 PyObject *resultobj = 0;
27573 wxPyApp *arg1 = (wxPyApp *) 0 ;
27574 wxAppTraits *result = 0 ;
27575 void *argp1 = 0 ;
27576 int res1 = 0 ;
27577 PyObject *swig_obj[1] ;
27578
27579 if (!args) SWIG_fail;
27580 swig_obj[0] = args;
27581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27582 if (!SWIG_IsOK(res1)) {
27583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27584 }
27585 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27586 {
27587 PyThreadState* __tstate = wxPyBeginAllowThreads();
27588 result = (wxAppTraits *)(arg1)->GetTraits();
27589 wxPyEndAllowThreads(__tstate);
27590 if (PyErr_Occurred()) SWIG_fail;
27591 }
27592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27593 return resultobj;
27594 fail:
27595 return NULL;
27596 }
27597
27598
27599 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27600 PyObject *resultobj = 0;
27601 wxPyApp *arg1 = (wxPyApp *) 0 ;
27602 void *argp1 = 0 ;
27603 int res1 = 0 ;
27604 PyObject *swig_obj[1] ;
27605
27606 if (!args) SWIG_fail;
27607 swig_obj[0] = args;
27608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27609 if (!SWIG_IsOK(res1)) {
27610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27611 }
27612 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27613 {
27614 PyThreadState* __tstate = wxPyBeginAllowThreads();
27615 (arg1)->ProcessPendingEvents();
27616 wxPyEndAllowThreads(__tstate);
27617 if (PyErr_Occurred()) SWIG_fail;
27618 }
27619 resultobj = SWIG_Py_Void();
27620 return resultobj;
27621 fail:
27622 return NULL;
27623 }
27624
27625
27626 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27627 PyObject *resultobj = 0;
27628 wxPyApp *arg1 = (wxPyApp *) 0 ;
27629 bool arg2 = (bool) false ;
27630 bool result;
27631 void *argp1 = 0 ;
27632 int res1 = 0 ;
27633 bool val2 ;
27634 int ecode2 = 0 ;
27635 PyObject * obj0 = 0 ;
27636 PyObject * obj1 = 0 ;
27637 char * kwnames[] = {
27638 (char *) "self",(char *) "onlyIfNeeded", NULL
27639 };
27640
27641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27643 if (!SWIG_IsOK(res1)) {
27644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27645 }
27646 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27647 if (obj1) {
27648 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27649 if (!SWIG_IsOK(ecode2)) {
27650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27651 }
27652 arg2 = static_cast< bool >(val2);
27653 }
27654 {
27655 PyThreadState* __tstate = wxPyBeginAllowThreads();
27656 result = (bool)(arg1)->Yield(arg2);
27657 wxPyEndAllowThreads(__tstate);
27658 if (PyErr_Occurred()) SWIG_fail;
27659 }
27660 {
27661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27662 }
27663 return resultobj;
27664 fail:
27665 return NULL;
27666 }
27667
27668
27669 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27670 PyObject *resultobj = 0;
27671 wxPyApp *arg1 = (wxPyApp *) 0 ;
27672 void *argp1 = 0 ;
27673 int res1 = 0 ;
27674 PyObject *swig_obj[1] ;
27675
27676 if (!args) SWIG_fail;
27677 swig_obj[0] = args;
27678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27679 if (!SWIG_IsOK(res1)) {
27680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27681 }
27682 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27683 {
27684 PyThreadState* __tstate = wxPyBeginAllowThreads();
27685 (arg1)->WakeUpIdle();
27686 wxPyEndAllowThreads(__tstate);
27687 if (PyErr_Occurred()) SWIG_fail;
27688 }
27689 resultobj = SWIG_Py_Void();
27690 return resultobj;
27691 fail:
27692 return NULL;
27693 }
27694
27695
27696 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27697 PyObject *resultobj = 0;
27698 bool result;
27699
27700 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27701 {
27702 PyThreadState* __tstate = wxPyBeginAllowThreads();
27703 result = (bool)wxPyApp::IsMainLoopRunning();
27704 wxPyEndAllowThreads(__tstate);
27705 if (PyErr_Occurred()) SWIG_fail;
27706 }
27707 {
27708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27709 }
27710 return resultobj;
27711 fail:
27712 return NULL;
27713 }
27714
27715
27716 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27717 PyObject *resultobj = 0;
27718 wxPyApp *arg1 = (wxPyApp *) 0 ;
27719 int result;
27720 void *argp1 = 0 ;
27721 int res1 = 0 ;
27722 PyObject *swig_obj[1] ;
27723
27724 if (!args) SWIG_fail;
27725 swig_obj[0] = args;
27726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27727 if (!SWIG_IsOK(res1)) {
27728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27729 }
27730 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27731 {
27732 PyThreadState* __tstate = wxPyBeginAllowThreads();
27733 result = (int)(arg1)->MainLoop();
27734 wxPyEndAllowThreads(__tstate);
27735 if (PyErr_Occurred()) SWIG_fail;
27736 }
27737 resultobj = SWIG_From_int(static_cast< int >(result));
27738 return resultobj;
27739 fail:
27740 return NULL;
27741 }
27742
27743
27744 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27745 PyObject *resultobj = 0;
27746 wxPyApp *arg1 = (wxPyApp *) 0 ;
27747 void *argp1 = 0 ;
27748 int res1 = 0 ;
27749 PyObject *swig_obj[1] ;
27750
27751 if (!args) SWIG_fail;
27752 swig_obj[0] = args;
27753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27754 if (!SWIG_IsOK(res1)) {
27755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27756 }
27757 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27758 {
27759 PyThreadState* __tstate = wxPyBeginAllowThreads();
27760 (arg1)->Exit();
27761 wxPyEndAllowThreads(__tstate);
27762 if (PyErr_Occurred()) SWIG_fail;
27763 }
27764 resultobj = SWIG_Py_Void();
27765 return resultobj;
27766 fail:
27767 return NULL;
27768 }
27769
27770
27771 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27772 PyObject *resultobj = 0;
27773 wxPyApp *arg1 = (wxPyApp *) 0 ;
27774 wxLayoutDirection result;
27775 void *argp1 = 0 ;
27776 int res1 = 0 ;
27777 PyObject *swig_obj[1] ;
27778
27779 if (!args) SWIG_fail;
27780 swig_obj[0] = args;
27781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27782 if (!SWIG_IsOK(res1)) {
27783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27784 }
27785 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27786 {
27787 PyThreadState* __tstate = wxPyBeginAllowThreads();
27788 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
27789 wxPyEndAllowThreads(__tstate);
27790 if (PyErr_Occurred()) SWIG_fail;
27791 }
27792 resultobj = SWIG_From_int(static_cast< int >(result));
27793 return resultobj;
27794 fail:
27795 return NULL;
27796 }
27797
27798
27799 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27800 PyObject *resultobj = 0;
27801 wxPyApp *arg1 = (wxPyApp *) 0 ;
27802 void *argp1 = 0 ;
27803 int res1 = 0 ;
27804 PyObject *swig_obj[1] ;
27805
27806 if (!args) SWIG_fail;
27807 swig_obj[0] = args;
27808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27809 if (!SWIG_IsOK(res1)) {
27810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27811 }
27812 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27813 {
27814 PyThreadState* __tstate = wxPyBeginAllowThreads();
27815 (arg1)->ExitMainLoop();
27816 wxPyEndAllowThreads(__tstate);
27817 if (PyErr_Occurred()) SWIG_fail;
27818 }
27819 resultobj = SWIG_Py_Void();
27820 return resultobj;
27821 fail:
27822 return NULL;
27823 }
27824
27825
27826 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27827 PyObject *resultobj = 0;
27828 wxPyApp *arg1 = (wxPyApp *) 0 ;
27829 bool result;
27830 void *argp1 = 0 ;
27831 int res1 = 0 ;
27832 PyObject *swig_obj[1] ;
27833
27834 if (!args) SWIG_fail;
27835 swig_obj[0] = args;
27836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27837 if (!SWIG_IsOK(res1)) {
27838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27839 }
27840 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27841 {
27842 PyThreadState* __tstate = wxPyBeginAllowThreads();
27843 result = (bool)(arg1)->Pending();
27844 wxPyEndAllowThreads(__tstate);
27845 if (PyErr_Occurred()) SWIG_fail;
27846 }
27847 {
27848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27849 }
27850 return resultobj;
27851 fail:
27852 return NULL;
27853 }
27854
27855
27856 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27857 PyObject *resultobj = 0;
27858 wxPyApp *arg1 = (wxPyApp *) 0 ;
27859 bool result;
27860 void *argp1 = 0 ;
27861 int res1 = 0 ;
27862 PyObject *swig_obj[1] ;
27863
27864 if (!args) SWIG_fail;
27865 swig_obj[0] = args;
27866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27867 if (!SWIG_IsOK(res1)) {
27868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27869 }
27870 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27871 {
27872 PyThreadState* __tstate = wxPyBeginAllowThreads();
27873 result = (bool)(arg1)->Dispatch();
27874 wxPyEndAllowThreads(__tstate);
27875 if (PyErr_Occurred()) SWIG_fail;
27876 }
27877 {
27878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27879 }
27880 return resultobj;
27881 fail:
27882 return NULL;
27883 }
27884
27885
27886 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27887 PyObject *resultobj = 0;
27888 wxPyApp *arg1 = (wxPyApp *) 0 ;
27889 bool result;
27890 void *argp1 = 0 ;
27891 int res1 = 0 ;
27892 PyObject *swig_obj[1] ;
27893
27894 if (!args) SWIG_fail;
27895 swig_obj[0] = args;
27896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27897 if (!SWIG_IsOK(res1)) {
27898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27899 }
27900 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27901 {
27902 PyThreadState* __tstate = wxPyBeginAllowThreads();
27903 result = (bool)(arg1)->ProcessIdle();
27904 wxPyEndAllowThreads(__tstate);
27905 if (PyErr_Occurred()) SWIG_fail;
27906 }
27907 {
27908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27909 }
27910 return resultobj;
27911 fail:
27912 return NULL;
27913 }
27914
27915
27916 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27917 PyObject *resultobj = 0;
27918 wxPyApp *arg1 = (wxPyApp *) 0 ;
27919 wxWindow *arg2 = (wxWindow *) 0 ;
27920 wxIdleEvent *arg3 = 0 ;
27921 bool result;
27922 void *argp1 = 0 ;
27923 int res1 = 0 ;
27924 void *argp2 = 0 ;
27925 int res2 = 0 ;
27926 void *argp3 = 0 ;
27927 int res3 = 0 ;
27928 PyObject * obj0 = 0 ;
27929 PyObject * obj1 = 0 ;
27930 PyObject * obj2 = 0 ;
27931 char * kwnames[] = {
27932 (char *) "self",(char *) "win",(char *) "event", NULL
27933 };
27934
27935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27937 if (!SWIG_IsOK(res1)) {
27938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27939 }
27940 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27941 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27942 if (!SWIG_IsOK(res2)) {
27943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27944 }
27945 arg2 = reinterpret_cast< wxWindow * >(argp2);
27946 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27947 if (!SWIG_IsOK(res3)) {
27948 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27949 }
27950 if (!argp3) {
27951 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27952 }
27953 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27954 {
27955 PyThreadState* __tstate = wxPyBeginAllowThreads();
27956 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27957 wxPyEndAllowThreads(__tstate);
27958 if (PyErr_Occurred()) SWIG_fail;
27959 }
27960 {
27961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27962 }
27963 return resultobj;
27964 fail:
27965 return NULL;
27966 }
27967
27968
27969 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27970 PyObject *resultobj = 0;
27971 wxPyApp *arg1 = (wxPyApp *) 0 ;
27972 bool result;
27973 void *argp1 = 0 ;
27974 int res1 = 0 ;
27975 PyObject *swig_obj[1] ;
27976
27977 if (!args) SWIG_fail;
27978 swig_obj[0] = args;
27979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27980 if (!SWIG_IsOK(res1)) {
27981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27982 }
27983 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27984 {
27985 PyThreadState* __tstate = wxPyBeginAllowThreads();
27986 result = (bool)((wxPyApp const *)arg1)->IsActive();
27987 wxPyEndAllowThreads(__tstate);
27988 if (PyErr_Occurred()) SWIG_fail;
27989 }
27990 {
27991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27992 }
27993 return resultobj;
27994 fail:
27995 return NULL;
27996 }
27997
27998
27999 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28000 PyObject *resultobj = 0;
28001 wxPyApp *arg1 = (wxPyApp *) 0 ;
28002 wxWindow *arg2 = (wxWindow *) 0 ;
28003 void *argp1 = 0 ;
28004 int res1 = 0 ;
28005 void *argp2 = 0 ;
28006 int res2 = 0 ;
28007 PyObject * obj0 = 0 ;
28008 PyObject * obj1 = 0 ;
28009 char * kwnames[] = {
28010 (char *) "self",(char *) "win", NULL
28011 };
28012
28013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28015 if (!SWIG_IsOK(res1)) {
28016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28017 }
28018 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28019 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28020 if (!SWIG_IsOK(res2)) {
28021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28022 }
28023 arg2 = reinterpret_cast< wxWindow * >(argp2);
28024 {
28025 PyThreadState* __tstate = wxPyBeginAllowThreads();
28026 (arg1)->SetTopWindow(arg2);
28027 wxPyEndAllowThreads(__tstate);
28028 if (PyErr_Occurred()) SWIG_fail;
28029 }
28030 resultobj = SWIG_Py_Void();
28031 return resultobj;
28032 fail:
28033 return NULL;
28034 }
28035
28036
28037 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28038 PyObject *resultobj = 0;
28039 wxPyApp *arg1 = (wxPyApp *) 0 ;
28040 wxWindow *result = 0 ;
28041 void *argp1 = 0 ;
28042 int res1 = 0 ;
28043 PyObject *swig_obj[1] ;
28044
28045 if (!args) SWIG_fail;
28046 swig_obj[0] = args;
28047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28048 if (!SWIG_IsOK(res1)) {
28049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28050 }
28051 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28052 {
28053 PyThreadState* __tstate = wxPyBeginAllowThreads();
28054 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28055 wxPyEndAllowThreads(__tstate);
28056 if (PyErr_Occurred()) SWIG_fail;
28057 }
28058 {
28059 resultobj = wxPyMake_wxObject(result, (bool)0);
28060 }
28061 return resultobj;
28062 fail:
28063 return NULL;
28064 }
28065
28066
28067 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28068 PyObject *resultobj = 0;
28069 wxPyApp *arg1 = (wxPyApp *) 0 ;
28070 bool arg2 ;
28071 void *argp1 = 0 ;
28072 int res1 = 0 ;
28073 bool val2 ;
28074 int ecode2 = 0 ;
28075 PyObject * obj0 = 0 ;
28076 PyObject * obj1 = 0 ;
28077 char * kwnames[] = {
28078 (char *) "self",(char *) "flag", NULL
28079 };
28080
28081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28083 if (!SWIG_IsOK(res1)) {
28084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28085 }
28086 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28087 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28088 if (!SWIG_IsOK(ecode2)) {
28089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28090 }
28091 arg2 = static_cast< bool >(val2);
28092 {
28093 PyThreadState* __tstate = wxPyBeginAllowThreads();
28094 (arg1)->SetExitOnFrameDelete(arg2);
28095 wxPyEndAllowThreads(__tstate);
28096 if (PyErr_Occurred()) SWIG_fail;
28097 }
28098 resultobj = SWIG_Py_Void();
28099 return resultobj;
28100 fail:
28101 return NULL;
28102 }
28103
28104
28105 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28106 PyObject *resultobj = 0;
28107 wxPyApp *arg1 = (wxPyApp *) 0 ;
28108 bool result;
28109 void *argp1 = 0 ;
28110 int res1 = 0 ;
28111 PyObject *swig_obj[1] ;
28112
28113 if (!args) SWIG_fail;
28114 swig_obj[0] = args;
28115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28116 if (!SWIG_IsOK(res1)) {
28117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28118 }
28119 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28120 {
28121 PyThreadState* __tstate = wxPyBeginAllowThreads();
28122 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28123 wxPyEndAllowThreads(__tstate);
28124 if (PyErr_Occurred()) SWIG_fail;
28125 }
28126 {
28127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28128 }
28129 return resultobj;
28130 fail:
28131 return NULL;
28132 }
28133
28134
28135 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28136 PyObject *resultobj = 0;
28137 wxPyApp *arg1 = (wxPyApp *) 0 ;
28138 bool arg2 ;
28139 void *argp1 = 0 ;
28140 int res1 = 0 ;
28141 bool val2 ;
28142 int ecode2 = 0 ;
28143 PyObject * obj0 = 0 ;
28144 PyObject * obj1 = 0 ;
28145 char * kwnames[] = {
28146 (char *) "self",(char *) "flag", NULL
28147 };
28148
28149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28151 if (!SWIG_IsOK(res1)) {
28152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28153 }
28154 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28155 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28156 if (!SWIG_IsOK(ecode2)) {
28157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28158 }
28159 arg2 = static_cast< bool >(val2);
28160 {
28161 PyThreadState* __tstate = wxPyBeginAllowThreads();
28162 (arg1)->SetUseBestVisual(arg2);
28163 wxPyEndAllowThreads(__tstate);
28164 if (PyErr_Occurred()) SWIG_fail;
28165 }
28166 resultobj = SWIG_Py_Void();
28167 return resultobj;
28168 fail:
28169 return NULL;
28170 }
28171
28172
28173 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28174 PyObject *resultobj = 0;
28175 wxPyApp *arg1 = (wxPyApp *) 0 ;
28176 bool result;
28177 void *argp1 = 0 ;
28178 int res1 = 0 ;
28179 PyObject *swig_obj[1] ;
28180
28181 if (!args) SWIG_fail;
28182 swig_obj[0] = args;
28183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28184 if (!SWIG_IsOK(res1)) {
28185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28186 }
28187 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28188 {
28189 PyThreadState* __tstate = wxPyBeginAllowThreads();
28190 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28191 wxPyEndAllowThreads(__tstate);
28192 if (PyErr_Occurred()) SWIG_fail;
28193 }
28194 {
28195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28196 }
28197 return resultobj;
28198 fail:
28199 return NULL;
28200 }
28201
28202
28203 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28204 PyObject *resultobj = 0;
28205 wxPyApp *arg1 = (wxPyApp *) 0 ;
28206 int arg2 ;
28207 void *argp1 = 0 ;
28208 int res1 = 0 ;
28209 int val2 ;
28210 int ecode2 = 0 ;
28211 PyObject * obj0 = 0 ;
28212 PyObject * obj1 = 0 ;
28213 char * kwnames[] = {
28214 (char *) "self",(char *) "mode", NULL
28215 };
28216
28217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28219 if (!SWIG_IsOK(res1)) {
28220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28221 }
28222 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28223 ecode2 = SWIG_AsVal_int(obj1, &val2);
28224 if (!SWIG_IsOK(ecode2)) {
28225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28226 }
28227 arg2 = static_cast< int >(val2);
28228 {
28229 PyThreadState* __tstate = wxPyBeginAllowThreads();
28230 (arg1)->SetPrintMode(arg2);
28231 wxPyEndAllowThreads(__tstate);
28232 if (PyErr_Occurred()) SWIG_fail;
28233 }
28234 resultobj = SWIG_Py_Void();
28235 return resultobj;
28236 fail:
28237 return NULL;
28238 }
28239
28240
28241 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28242 PyObject *resultobj = 0;
28243 wxPyApp *arg1 = (wxPyApp *) 0 ;
28244 int result;
28245 void *argp1 = 0 ;
28246 int res1 = 0 ;
28247 PyObject *swig_obj[1] ;
28248
28249 if (!args) SWIG_fail;
28250 swig_obj[0] = args;
28251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28252 if (!SWIG_IsOK(res1)) {
28253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28254 }
28255 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28256 {
28257 PyThreadState* __tstate = wxPyBeginAllowThreads();
28258 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28259 wxPyEndAllowThreads(__tstate);
28260 if (PyErr_Occurred()) SWIG_fail;
28261 }
28262 resultobj = SWIG_From_int(static_cast< int >(result));
28263 return resultobj;
28264 fail:
28265 return NULL;
28266 }
28267
28268
28269 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28270 PyObject *resultobj = 0;
28271 wxPyApp *arg1 = (wxPyApp *) 0 ;
28272 int arg2 ;
28273 void *argp1 = 0 ;
28274 int res1 = 0 ;
28275 int val2 ;
28276 int ecode2 = 0 ;
28277 PyObject * obj0 = 0 ;
28278 PyObject * obj1 = 0 ;
28279 char * kwnames[] = {
28280 (char *) "self",(char *) "mode", NULL
28281 };
28282
28283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28285 if (!SWIG_IsOK(res1)) {
28286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28287 }
28288 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28289 ecode2 = SWIG_AsVal_int(obj1, &val2);
28290 if (!SWIG_IsOK(ecode2)) {
28291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28292 }
28293 arg2 = static_cast< int >(val2);
28294 {
28295 PyThreadState* __tstate = wxPyBeginAllowThreads();
28296 (arg1)->SetAssertMode(arg2);
28297 wxPyEndAllowThreads(__tstate);
28298 if (PyErr_Occurred()) SWIG_fail;
28299 }
28300 resultobj = SWIG_Py_Void();
28301 return resultobj;
28302 fail:
28303 return NULL;
28304 }
28305
28306
28307 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28308 PyObject *resultobj = 0;
28309 wxPyApp *arg1 = (wxPyApp *) 0 ;
28310 int result;
28311 void *argp1 = 0 ;
28312 int res1 = 0 ;
28313 PyObject *swig_obj[1] ;
28314
28315 if (!args) SWIG_fail;
28316 swig_obj[0] = args;
28317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28318 if (!SWIG_IsOK(res1)) {
28319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28320 }
28321 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28322 {
28323 PyThreadState* __tstate = wxPyBeginAllowThreads();
28324 result = (int)(arg1)->GetAssertMode();
28325 wxPyEndAllowThreads(__tstate);
28326 if (PyErr_Occurred()) SWIG_fail;
28327 }
28328 resultobj = SWIG_From_int(static_cast< int >(result));
28329 return resultobj;
28330 fail:
28331 return NULL;
28332 }
28333
28334
28335 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28336 PyObject *resultobj = 0;
28337 bool result;
28338
28339 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28340 {
28341 PyThreadState* __tstate = wxPyBeginAllowThreads();
28342 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28343 wxPyEndAllowThreads(__tstate);
28344 if (PyErr_Occurred()) SWIG_fail;
28345 }
28346 {
28347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28348 }
28349 return resultobj;
28350 fail:
28351 return NULL;
28352 }
28353
28354
28355 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28356 PyObject *resultobj = 0;
28357 long result;
28358
28359 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28360 {
28361 PyThreadState* __tstate = wxPyBeginAllowThreads();
28362 result = (long)wxPyApp::GetMacAboutMenuItemId();
28363 wxPyEndAllowThreads(__tstate);
28364 if (PyErr_Occurred()) SWIG_fail;
28365 }
28366 resultobj = SWIG_From_long(static_cast< long >(result));
28367 return resultobj;
28368 fail:
28369 return NULL;
28370 }
28371
28372
28373 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28374 PyObject *resultobj = 0;
28375 long result;
28376
28377 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28378 {
28379 PyThreadState* __tstate = wxPyBeginAllowThreads();
28380 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28381 wxPyEndAllowThreads(__tstate);
28382 if (PyErr_Occurred()) SWIG_fail;
28383 }
28384 resultobj = SWIG_From_long(static_cast< long >(result));
28385 return resultobj;
28386 fail:
28387 return NULL;
28388 }
28389
28390
28391 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28392 PyObject *resultobj = 0;
28393 long result;
28394
28395 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28396 {
28397 PyThreadState* __tstate = wxPyBeginAllowThreads();
28398 result = (long)wxPyApp::GetMacExitMenuItemId();
28399 wxPyEndAllowThreads(__tstate);
28400 if (PyErr_Occurred()) SWIG_fail;
28401 }
28402 resultobj = SWIG_From_long(static_cast< long >(result));
28403 return resultobj;
28404 fail:
28405 return NULL;
28406 }
28407
28408
28409 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28410 PyObject *resultobj = 0;
28411 wxString result;
28412
28413 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28414 {
28415 PyThreadState* __tstate = wxPyBeginAllowThreads();
28416 result = wxPyApp::GetMacHelpMenuTitleName();
28417 wxPyEndAllowThreads(__tstate);
28418 if (PyErr_Occurred()) SWIG_fail;
28419 }
28420 {
28421 #if wxUSE_UNICODE
28422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28423 #else
28424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28425 #endif
28426 }
28427 return resultobj;
28428 fail:
28429 return NULL;
28430 }
28431
28432
28433 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28434 PyObject *resultobj = 0;
28435 bool arg1 ;
28436 bool val1 ;
28437 int ecode1 = 0 ;
28438 PyObject * obj0 = 0 ;
28439 char * kwnames[] = {
28440 (char *) "val", NULL
28441 };
28442
28443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28444 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28445 if (!SWIG_IsOK(ecode1)) {
28446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28447 }
28448 arg1 = static_cast< bool >(val1);
28449 {
28450 PyThreadState* __tstate = wxPyBeginAllowThreads();
28451 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28452 wxPyEndAllowThreads(__tstate);
28453 if (PyErr_Occurred()) SWIG_fail;
28454 }
28455 resultobj = SWIG_Py_Void();
28456 return resultobj;
28457 fail:
28458 return NULL;
28459 }
28460
28461
28462 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28463 PyObject *resultobj = 0;
28464 long arg1 ;
28465 long val1 ;
28466 int ecode1 = 0 ;
28467 PyObject * obj0 = 0 ;
28468 char * kwnames[] = {
28469 (char *) "val", NULL
28470 };
28471
28472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28473 ecode1 = SWIG_AsVal_long(obj0, &val1);
28474 if (!SWIG_IsOK(ecode1)) {
28475 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28476 }
28477 arg1 = static_cast< long >(val1);
28478 {
28479 PyThreadState* __tstate = wxPyBeginAllowThreads();
28480 wxPyApp::SetMacAboutMenuItemId(arg1);
28481 wxPyEndAllowThreads(__tstate);
28482 if (PyErr_Occurred()) SWIG_fail;
28483 }
28484 resultobj = SWIG_Py_Void();
28485 return resultobj;
28486 fail:
28487 return NULL;
28488 }
28489
28490
28491 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28492 PyObject *resultobj = 0;
28493 long arg1 ;
28494 long val1 ;
28495 int ecode1 = 0 ;
28496 PyObject * obj0 = 0 ;
28497 char * kwnames[] = {
28498 (char *) "val", NULL
28499 };
28500
28501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28502 ecode1 = SWIG_AsVal_long(obj0, &val1);
28503 if (!SWIG_IsOK(ecode1)) {
28504 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28505 }
28506 arg1 = static_cast< long >(val1);
28507 {
28508 PyThreadState* __tstate = wxPyBeginAllowThreads();
28509 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28510 wxPyEndAllowThreads(__tstate);
28511 if (PyErr_Occurred()) SWIG_fail;
28512 }
28513 resultobj = SWIG_Py_Void();
28514 return resultobj;
28515 fail:
28516 return NULL;
28517 }
28518
28519
28520 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28521 PyObject *resultobj = 0;
28522 long arg1 ;
28523 long val1 ;
28524 int ecode1 = 0 ;
28525 PyObject * obj0 = 0 ;
28526 char * kwnames[] = {
28527 (char *) "val", NULL
28528 };
28529
28530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28531 ecode1 = SWIG_AsVal_long(obj0, &val1);
28532 if (!SWIG_IsOK(ecode1)) {
28533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28534 }
28535 arg1 = static_cast< long >(val1);
28536 {
28537 PyThreadState* __tstate = wxPyBeginAllowThreads();
28538 wxPyApp::SetMacExitMenuItemId(arg1);
28539 wxPyEndAllowThreads(__tstate);
28540 if (PyErr_Occurred()) SWIG_fail;
28541 }
28542 resultobj = SWIG_Py_Void();
28543 return resultobj;
28544 fail:
28545 return NULL;
28546 }
28547
28548
28549 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28550 PyObject *resultobj = 0;
28551 wxString *arg1 = 0 ;
28552 bool temp1 = false ;
28553 PyObject * obj0 = 0 ;
28554 char * kwnames[] = {
28555 (char *) "val", NULL
28556 };
28557
28558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28559 {
28560 arg1 = wxString_in_helper(obj0);
28561 if (arg1 == NULL) SWIG_fail;
28562 temp1 = true;
28563 }
28564 {
28565 PyThreadState* __tstate = wxPyBeginAllowThreads();
28566 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28567 wxPyEndAllowThreads(__tstate);
28568 if (PyErr_Occurred()) SWIG_fail;
28569 }
28570 resultobj = SWIG_Py_Void();
28571 {
28572 if (temp1)
28573 delete arg1;
28574 }
28575 return resultobj;
28576 fail:
28577 {
28578 if (temp1)
28579 delete arg1;
28580 }
28581 return NULL;
28582 }
28583
28584
28585 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28586 PyObject *resultobj = 0;
28587 wxPyApp *arg1 = (wxPyApp *) 0 ;
28588 void *argp1 = 0 ;
28589 int res1 = 0 ;
28590 PyObject *swig_obj[1] ;
28591
28592 if (!args) SWIG_fail;
28593 swig_obj[0] = args;
28594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28595 if (!SWIG_IsOK(res1)) {
28596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28597 }
28598 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28599 {
28600 PyThreadState* __tstate = wxPyBeginAllowThreads();
28601 (arg1)->_BootstrapApp();
28602 wxPyEndAllowThreads(__tstate);
28603 if (PyErr_Occurred()) SWIG_fail;
28604 }
28605 resultobj = SWIG_Py_Void();
28606 return resultobj;
28607 fail:
28608 return NULL;
28609 }
28610
28611
28612 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28613 PyObject *resultobj = 0;
28614 int result;
28615
28616 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28617 {
28618 PyThreadState* __tstate = wxPyBeginAllowThreads();
28619 result = (int)wxPyApp_GetComCtl32Version();
28620 wxPyEndAllowThreads(__tstate);
28621 if (PyErr_Occurred()) SWIG_fail;
28622 }
28623 resultobj = SWIG_From_int(static_cast< int >(result));
28624 return resultobj;
28625 fail:
28626 return NULL;
28627 }
28628
28629
28630 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28631 PyObject *resultobj = 0;
28632 bool result;
28633
28634 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
28635 {
28636 PyThreadState* __tstate = wxPyBeginAllowThreads();
28637 result = (bool)wxPyApp_IsDisplayAvailable();
28638 wxPyEndAllowThreads(__tstate);
28639 if (PyErr_Occurred()) SWIG_fail;
28640 }
28641 {
28642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28643 }
28644 return resultobj;
28645 fail:
28646 return NULL;
28647 }
28648
28649
28650 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28651 PyObject *obj;
28652 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28653 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28654 return SWIG_Py_Void();
28655 }
28656
28657 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28658 return SWIG_Python_InitShadowInstance(args);
28659 }
28660
28661 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28662 PyObject *resultobj = 0;
28663
28664 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28665 {
28666 PyThreadState* __tstate = wxPyBeginAllowThreads();
28667 wxExit();
28668 wxPyEndAllowThreads(__tstate);
28669 if (PyErr_Occurred()) SWIG_fail;
28670 }
28671 resultobj = SWIG_Py_Void();
28672 return resultobj;
28673 fail:
28674 return NULL;
28675 }
28676
28677
28678 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28679 PyObject *resultobj = 0;
28680 bool result;
28681
28682 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28683 {
28684 PyThreadState* __tstate = wxPyBeginAllowThreads();
28685 result = (bool)wxYield();
28686 wxPyEndAllowThreads(__tstate);
28687 if (PyErr_Occurred()) SWIG_fail;
28688 }
28689 {
28690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28691 }
28692 return resultobj;
28693 fail:
28694 return NULL;
28695 }
28696
28697
28698 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28699 PyObject *resultobj = 0;
28700 bool result;
28701
28702 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28703 {
28704 PyThreadState* __tstate = wxPyBeginAllowThreads();
28705 result = (bool)wxYieldIfNeeded();
28706 wxPyEndAllowThreads(__tstate);
28707 if (PyErr_Occurred()) SWIG_fail;
28708 }
28709 {
28710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28711 }
28712 return resultobj;
28713 fail:
28714 return NULL;
28715 }
28716
28717
28718 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28719 PyObject *resultobj = 0;
28720 wxWindow *arg1 = (wxWindow *) NULL ;
28721 bool arg2 = (bool) false ;
28722 bool result;
28723 void *argp1 = 0 ;
28724 int res1 = 0 ;
28725 bool val2 ;
28726 int ecode2 = 0 ;
28727 PyObject * obj0 = 0 ;
28728 PyObject * obj1 = 0 ;
28729 char * kwnames[] = {
28730 (char *) "win",(char *) "onlyIfNeeded", NULL
28731 };
28732
28733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28734 if (obj0) {
28735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28736 if (!SWIG_IsOK(res1)) {
28737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28738 }
28739 arg1 = reinterpret_cast< wxWindow * >(argp1);
28740 }
28741 if (obj1) {
28742 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28743 if (!SWIG_IsOK(ecode2)) {
28744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28745 }
28746 arg2 = static_cast< bool >(val2);
28747 }
28748 {
28749 PyThreadState* __tstate = wxPyBeginAllowThreads();
28750 result = (bool)wxSafeYield(arg1,arg2);
28751 wxPyEndAllowThreads(__tstate);
28752 if (PyErr_Occurred()) SWIG_fail;
28753 }
28754 {
28755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28756 }
28757 return resultobj;
28758 fail:
28759 return NULL;
28760 }
28761
28762
28763 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28764 PyObject *resultobj = 0;
28765
28766 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28767 {
28768 PyThreadState* __tstate = wxPyBeginAllowThreads();
28769 wxWakeUpIdle();
28770 wxPyEndAllowThreads(__tstate);
28771 if (PyErr_Occurred()) SWIG_fail;
28772 }
28773 resultobj = SWIG_Py_Void();
28774 return resultobj;
28775 fail:
28776 return NULL;
28777 }
28778
28779
28780 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28781 PyObject *resultobj = 0;
28782 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28783 wxEvent *arg2 = 0 ;
28784 void *argp1 = 0 ;
28785 int res1 = 0 ;
28786 void *argp2 = 0 ;
28787 int res2 = 0 ;
28788 PyObject * obj0 = 0 ;
28789 PyObject * obj1 = 0 ;
28790 char * kwnames[] = {
28791 (char *) "dest",(char *) "event", NULL
28792 };
28793
28794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28796 if (!SWIG_IsOK(res1)) {
28797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28798 }
28799 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28800 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28801 if (!SWIG_IsOK(res2)) {
28802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28803 }
28804 if (!argp2) {
28805 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28806 }
28807 arg2 = reinterpret_cast< wxEvent * >(argp2);
28808 {
28809 PyThreadState* __tstate = wxPyBeginAllowThreads();
28810 wxPostEvent(arg1,*arg2);
28811 wxPyEndAllowThreads(__tstate);
28812 if (PyErr_Occurred()) SWIG_fail;
28813 }
28814 resultobj = SWIG_Py_Void();
28815 return resultobj;
28816 fail:
28817 return NULL;
28818 }
28819
28820
28821 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28822 PyObject *resultobj = 0;
28823
28824 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28825 {
28826 PyThreadState* __tstate = wxPyBeginAllowThreads();
28827 wxApp_CleanUp();
28828 wxPyEndAllowThreads(__tstate);
28829 if (PyErr_Occurred()) SWIG_fail;
28830 }
28831 resultobj = SWIG_Py_Void();
28832 return resultobj;
28833 fail:
28834 return NULL;
28835 }
28836
28837
28838 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28839 PyObject *resultobj = 0;
28840 wxPyApp *result = 0 ;
28841
28842 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28843 {
28844 PyThreadState* __tstate = wxPyBeginAllowThreads();
28845 result = (wxPyApp *)wxPyGetApp();
28846 wxPyEndAllowThreads(__tstate);
28847 if (PyErr_Occurred()) SWIG_fail;
28848 }
28849 {
28850 resultobj = wxPyMake_wxObject(result, 0);
28851 }
28852 return resultobj;
28853 fail:
28854 return NULL;
28855 }
28856
28857
28858 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28859 PyObject *resultobj = 0;
28860 char *arg1 = (char *) 0 ;
28861 int res1 ;
28862 char *buf1 = 0 ;
28863 int alloc1 = 0 ;
28864 PyObject * obj0 = 0 ;
28865 char * kwnames[] = {
28866 (char *) "encoding", NULL
28867 };
28868
28869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28870 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28871 if (!SWIG_IsOK(res1)) {
28872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28873 }
28874 arg1 = buf1;
28875 {
28876 PyThreadState* __tstate = wxPyBeginAllowThreads();
28877 wxSetDefaultPyEncoding((char const *)arg1);
28878 wxPyEndAllowThreads(__tstate);
28879 if (PyErr_Occurred()) SWIG_fail;
28880 }
28881 resultobj = SWIG_Py_Void();
28882 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28883 return resultobj;
28884 fail:
28885 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28886 return NULL;
28887 }
28888
28889
28890 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28891 PyObject *resultobj = 0;
28892 char *result = 0 ;
28893
28894 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28895 {
28896 PyThreadState* __tstate = wxPyBeginAllowThreads();
28897 result = (char *)wxGetDefaultPyEncoding();
28898 wxPyEndAllowThreads(__tstate);
28899 if (PyErr_Occurred()) SWIG_fail;
28900 }
28901 resultobj = SWIG_FromCharPtr(result);
28902 return resultobj;
28903 fail:
28904 return NULL;
28905 }
28906
28907
28908 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28909 PyObject *resultobj = 0;
28910 wxEventLoop *result = 0 ;
28911
28912 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28913 {
28914 PyThreadState* __tstate = wxPyBeginAllowThreads();
28915 result = (wxEventLoop *)new wxEventLoop();
28916 wxPyEndAllowThreads(__tstate);
28917 if (PyErr_Occurred()) SWIG_fail;
28918 }
28919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28920 return resultobj;
28921 fail:
28922 return NULL;
28923 }
28924
28925
28926 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28927 PyObject *resultobj = 0;
28928 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28929 void *argp1 = 0 ;
28930 int res1 = 0 ;
28931 PyObject *swig_obj[1] ;
28932
28933 if (!args) SWIG_fail;
28934 swig_obj[0] = args;
28935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28936 if (!SWIG_IsOK(res1)) {
28937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28938 }
28939 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28940 {
28941 PyThreadState* __tstate = wxPyBeginAllowThreads();
28942 delete arg1;
28943
28944 wxPyEndAllowThreads(__tstate);
28945 if (PyErr_Occurred()) SWIG_fail;
28946 }
28947 resultobj = SWIG_Py_Void();
28948 return resultobj;
28949 fail:
28950 return NULL;
28951 }
28952
28953
28954 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28955 PyObject *resultobj = 0;
28956 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28957 int result;
28958 void *argp1 = 0 ;
28959 int res1 = 0 ;
28960 PyObject *swig_obj[1] ;
28961
28962 if (!args) SWIG_fail;
28963 swig_obj[0] = args;
28964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28965 if (!SWIG_IsOK(res1)) {
28966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28967 }
28968 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28969 {
28970 PyThreadState* __tstate = wxPyBeginAllowThreads();
28971 result = (int)(arg1)->Run();
28972 wxPyEndAllowThreads(__tstate);
28973 if (PyErr_Occurred()) SWIG_fail;
28974 }
28975 resultobj = SWIG_From_int(static_cast< int >(result));
28976 return resultobj;
28977 fail:
28978 return NULL;
28979 }
28980
28981
28982 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28983 PyObject *resultobj = 0;
28984 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28985 int arg2 = (int) 0 ;
28986 void *argp1 = 0 ;
28987 int res1 = 0 ;
28988 int val2 ;
28989 int ecode2 = 0 ;
28990 PyObject * obj0 = 0 ;
28991 PyObject * obj1 = 0 ;
28992 char * kwnames[] = {
28993 (char *) "self",(char *) "rc", NULL
28994 };
28995
28996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28998 if (!SWIG_IsOK(res1)) {
28999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29000 }
29001 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29002 if (obj1) {
29003 ecode2 = SWIG_AsVal_int(obj1, &val2);
29004 if (!SWIG_IsOK(ecode2)) {
29005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29006 }
29007 arg2 = static_cast< int >(val2);
29008 }
29009 {
29010 PyThreadState* __tstate = wxPyBeginAllowThreads();
29011 (arg1)->Exit(arg2);
29012 wxPyEndAllowThreads(__tstate);
29013 if (PyErr_Occurred()) SWIG_fail;
29014 }
29015 resultobj = SWIG_Py_Void();
29016 return resultobj;
29017 fail:
29018 return NULL;
29019 }
29020
29021
29022 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29023 PyObject *resultobj = 0;
29024 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29025 bool result;
29026 void *argp1 = 0 ;
29027 int res1 = 0 ;
29028 PyObject *swig_obj[1] ;
29029
29030 if (!args) SWIG_fail;
29031 swig_obj[0] = args;
29032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29033 if (!SWIG_IsOK(res1)) {
29034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29035 }
29036 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29037 {
29038 PyThreadState* __tstate = wxPyBeginAllowThreads();
29039 result = (bool)((wxEventLoop const *)arg1)->Pending();
29040 wxPyEndAllowThreads(__tstate);
29041 if (PyErr_Occurred()) SWIG_fail;
29042 }
29043 {
29044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29045 }
29046 return resultobj;
29047 fail:
29048 return NULL;
29049 }
29050
29051
29052 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29053 PyObject *resultobj = 0;
29054 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29055 bool result;
29056 void *argp1 = 0 ;
29057 int res1 = 0 ;
29058 PyObject *swig_obj[1] ;
29059
29060 if (!args) SWIG_fail;
29061 swig_obj[0] = args;
29062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29063 if (!SWIG_IsOK(res1)) {
29064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29065 }
29066 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29067 {
29068 PyThreadState* __tstate = wxPyBeginAllowThreads();
29069 result = (bool)(arg1)->Dispatch();
29070 wxPyEndAllowThreads(__tstate);
29071 if (PyErr_Occurred()) SWIG_fail;
29072 }
29073 {
29074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29075 }
29076 return resultobj;
29077 fail:
29078 return NULL;
29079 }
29080
29081
29082 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29083 PyObject *resultobj = 0;
29084 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29085 bool result;
29086 void *argp1 = 0 ;
29087 int res1 = 0 ;
29088 PyObject *swig_obj[1] ;
29089
29090 if (!args) SWIG_fail;
29091 swig_obj[0] = args;
29092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29093 if (!SWIG_IsOK(res1)) {
29094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29095 }
29096 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29097 {
29098 PyThreadState* __tstate = wxPyBeginAllowThreads();
29099 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29100 wxPyEndAllowThreads(__tstate);
29101 if (PyErr_Occurred()) SWIG_fail;
29102 }
29103 {
29104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29105 }
29106 return resultobj;
29107 fail:
29108 return NULL;
29109 }
29110
29111
29112 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29113 PyObject *resultobj = 0;
29114 wxEventLoop *result = 0 ;
29115
29116 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29117 {
29118 PyThreadState* __tstate = wxPyBeginAllowThreads();
29119 result = (wxEventLoop *)wxEventLoop::GetActive();
29120 wxPyEndAllowThreads(__tstate);
29121 if (PyErr_Occurred()) SWIG_fail;
29122 }
29123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29124 return resultobj;
29125 fail:
29126 return NULL;
29127 }
29128
29129
29130 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29131 PyObject *resultobj = 0;
29132 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29133 void *argp1 = 0 ;
29134 int res1 = 0 ;
29135 PyObject * obj0 = 0 ;
29136 char * kwnames[] = {
29137 (char *) "loop", NULL
29138 };
29139
29140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29142 if (!SWIG_IsOK(res1)) {
29143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29144 }
29145 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29146 {
29147 PyThreadState* __tstate = wxPyBeginAllowThreads();
29148 wxEventLoop::SetActive(arg1);
29149 wxPyEndAllowThreads(__tstate);
29150 if (PyErr_Occurred()) SWIG_fail;
29151 }
29152 resultobj = SWIG_Py_Void();
29153 return resultobj;
29154 fail:
29155 return NULL;
29156 }
29157
29158
29159 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29160 PyObject *obj;
29161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29162 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29163 return SWIG_Py_Void();
29164 }
29165
29166 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29167 return SWIG_Python_InitShadowInstance(args);
29168 }
29169
29170 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29171 PyObject *resultobj = 0;
29172 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29173 wxEventLoopActivator *result = 0 ;
29174 void *argp1 = 0 ;
29175 int res1 = 0 ;
29176 PyObject * obj0 = 0 ;
29177 char * kwnames[] = {
29178 (char *) "evtLoop", NULL
29179 };
29180
29181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29183 if (!SWIG_IsOK(res1)) {
29184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29185 }
29186 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29187 {
29188 PyThreadState* __tstate = wxPyBeginAllowThreads();
29189 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29190 wxPyEndAllowThreads(__tstate);
29191 if (PyErr_Occurred()) SWIG_fail;
29192 }
29193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29194 return resultobj;
29195 fail:
29196 return NULL;
29197 }
29198
29199
29200 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29201 PyObject *resultobj = 0;
29202 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29203 void *argp1 = 0 ;
29204 int res1 = 0 ;
29205 PyObject *swig_obj[1] ;
29206
29207 if (!args) SWIG_fail;
29208 swig_obj[0] = args;
29209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29210 if (!SWIG_IsOK(res1)) {
29211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29212 }
29213 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29214 {
29215 PyThreadState* __tstate = wxPyBeginAllowThreads();
29216 delete arg1;
29217
29218 wxPyEndAllowThreads(__tstate);
29219 if (PyErr_Occurred()) SWIG_fail;
29220 }
29221 resultobj = SWIG_Py_Void();
29222 return resultobj;
29223 fail:
29224 return NULL;
29225 }
29226
29227
29228 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29229 PyObject *obj;
29230 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29231 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29232 return SWIG_Py_Void();
29233 }
29234
29235 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29236 return SWIG_Python_InitShadowInstance(args);
29237 }
29238
29239 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29240 PyObject *resultobj = 0;
29241 int arg1 = (int) 0 ;
29242 int arg2 = (int) 0 ;
29243 int arg3 = (int) 0 ;
29244 wxAcceleratorEntry *result = 0 ;
29245 int val1 ;
29246 int ecode1 = 0 ;
29247 int val2 ;
29248 int ecode2 = 0 ;
29249 int val3 ;
29250 int ecode3 = 0 ;
29251 PyObject * obj0 = 0 ;
29252 PyObject * obj1 = 0 ;
29253 PyObject * obj2 = 0 ;
29254 char * kwnames[] = {
29255 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29256 };
29257
29258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29259 if (obj0) {
29260 ecode1 = SWIG_AsVal_int(obj0, &val1);
29261 if (!SWIG_IsOK(ecode1)) {
29262 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29263 }
29264 arg1 = static_cast< int >(val1);
29265 }
29266 if (obj1) {
29267 ecode2 = SWIG_AsVal_int(obj1, &val2);
29268 if (!SWIG_IsOK(ecode2)) {
29269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29270 }
29271 arg2 = static_cast< int >(val2);
29272 }
29273 if (obj2) {
29274 ecode3 = SWIG_AsVal_int(obj2, &val3);
29275 if (!SWIG_IsOK(ecode3)) {
29276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29277 }
29278 arg3 = static_cast< int >(val3);
29279 }
29280 {
29281 PyThreadState* __tstate = wxPyBeginAllowThreads();
29282 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29283 wxPyEndAllowThreads(__tstate);
29284 if (PyErr_Occurred()) SWIG_fail;
29285 }
29286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29287 return resultobj;
29288 fail:
29289 return NULL;
29290 }
29291
29292
29293 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29294 PyObject *resultobj = 0;
29295 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29296 void *argp1 = 0 ;
29297 int res1 = 0 ;
29298 PyObject *swig_obj[1] ;
29299
29300 if (!args) SWIG_fail;
29301 swig_obj[0] = args;
29302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29303 if (!SWIG_IsOK(res1)) {
29304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29305 }
29306 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29307 {
29308 PyThreadState* __tstate = wxPyBeginAllowThreads();
29309 delete arg1;
29310
29311 wxPyEndAllowThreads(__tstate);
29312 if (PyErr_Occurred()) SWIG_fail;
29313 }
29314 resultobj = SWIG_Py_Void();
29315 return resultobj;
29316 fail:
29317 return NULL;
29318 }
29319
29320
29321 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29322 PyObject *resultobj = 0;
29323 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29324 int arg2 ;
29325 int arg3 ;
29326 int arg4 ;
29327 void *argp1 = 0 ;
29328 int res1 = 0 ;
29329 int val2 ;
29330 int ecode2 = 0 ;
29331 int val3 ;
29332 int ecode3 = 0 ;
29333 int val4 ;
29334 int ecode4 = 0 ;
29335 PyObject * obj0 = 0 ;
29336 PyObject * obj1 = 0 ;
29337 PyObject * obj2 = 0 ;
29338 PyObject * obj3 = 0 ;
29339 char * kwnames[] = {
29340 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29341 };
29342
29343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29345 if (!SWIG_IsOK(res1)) {
29346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29347 }
29348 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29349 ecode2 = SWIG_AsVal_int(obj1, &val2);
29350 if (!SWIG_IsOK(ecode2)) {
29351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29352 }
29353 arg2 = static_cast< int >(val2);
29354 ecode3 = SWIG_AsVal_int(obj2, &val3);
29355 if (!SWIG_IsOK(ecode3)) {
29356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29357 }
29358 arg3 = static_cast< int >(val3);
29359 ecode4 = SWIG_AsVal_int(obj3, &val4);
29360 if (!SWIG_IsOK(ecode4)) {
29361 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29362 }
29363 arg4 = static_cast< int >(val4);
29364 {
29365 PyThreadState* __tstate = wxPyBeginAllowThreads();
29366 (arg1)->Set(arg2,arg3,arg4);
29367 wxPyEndAllowThreads(__tstate);
29368 if (PyErr_Occurred()) SWIG_fail;
29369 }
29370 resultobj = SWIG_Py_Void();
29371 return resultobj;
29372 fail:
29373 return NULL;
29374 }
29375
29376
29377 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29378 PyObject *resultobj = 0;
29379 wxString *arg1 = 0 ;
29380 wxAcceleratorEntry *result = 0 ;
29381 bool temp1 = false ;
29382 PyObject * obj0 = 0 ;
29383 char * kwnames[] = {
29384 (char *) "str", NULL
29385 };
29386
29387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29388 {
29389 arg1 = wxString_in_helper(obj0);
29390 if (arg1 == NULL) SWIG_fail;
29391 temp1 = true;
29392 }
29393 {
29394 PyThreadState* __tstate = wxPyBeginAllowThreads();
29395 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29396 wxPyEndAllowThreads(__tstate);
29397 if (PyErr_Occurred()) SWIG_fail;
29398 }
29399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29400 {
29401 if (temp1)
29402 delete arg1;
29403 }
29404 return resultobj;
29405 fail:
29406 {
29407 if (temp1)
29408 delete arg1;
29409 }
29410 return NULL;
29411 }
29412
29413
29414 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29415 PyObject *resultobj = 0;
29416 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29417 int result;
29418 void *argp1 = 0 ;
29419 int res1 = 0 ;
29420 PyObject *swig_obj[1] ;
29421
29422 if (!args) SWIG_fail;
29423 swig_obj[0] = args;
29424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29425 if (!SWIG_IsOK(res1)) {
29426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29427 }
29428 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29429 {
29430 PyThreadState* __tstate = wxPyBeginAllowThreads();
29431 result = (int)(arg1)->GetFlags();
29432 wxPyEndAllowThreads(__tstate);
29433 if (PyErr_Occurred()) SWIG_fail;
29434 }
29435 resultobj = SWIG_From_int(static_cast< int >(result));
29436 return resultobj;
29437 fail:
29438 return NULL;
29439 }
29440
29441
29442 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29443 PyObject *resultobj = 0;
29444 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29445 int result;
29446 void *argp1 = 0 ;
29447 int res1 = 0 ;
29448 PyObject *swig_obj[1] ;
29449
29450 if (!args) SWIG_fail;
29451 swig_obj[0] = args;
29452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29453 if (!SWIG_IsOK(res1)) {
29454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29455 }
29456 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29457 {
29458 PyThreadState* __tstate = wxPyBeginAllowThreads();
29459 result = (int)(arg1)->GetKeyCode();
29460 wxPyEndAllowThreads(__tstate);
29461 if (PyErr_Occurred()) SWIG_fail;
29462 }
29463 resultobj = SWIG_From_int(static_cast< int >(result));
29464 return resultobj;
29465 fail:
29466 return NULL;
29467 }
29468
29469
29470 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29471 PyObject *resultobj = 0;
29472 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29473 int result;
29474 void *argp1 = 0 ;
29475 int res1 = 0 ;
29476 PyObject *swig_obj[1] ;
29477
29478 if (!args) SWIG_fail;
29479 swig_obj[0] = args;
29480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29481 if (!SWIG_IsOK(res1)) {
29482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29483 }
29484 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29485 {
29486 PyThreadState* __tstate = wxPyBeginAllowThreads();
29487 result = (int)(arg1)->GetCommand();
29488 wxPyEndAllowThreads(__tstate);
29489 if (PyErr_Occurred()) SWIG_fail;
29490 }
29491 resultobj = SWIG_From_int(static_cast< int >(result));
29492 return resultobj;
29493 fail:
29494 return NULL;
29495 }
29496
29497
29498 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29499 PyObject *resultobj = 0;
29500 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29501 bool result;
29502 void *argp1 = 0 ;
29503 int res1 = 0 ;
29504 PyObject *swig_obj[1] ;
29505
29506 if (!args) SWIG_fail;
29507 swig_obj[0] = args;
29508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29509 if (!SWIG_IsOK(res1)) {
29510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29511 }
29512 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29513 {
29514 PyThreadState* __tstate = wxPyBeginAllowThreads();
29515 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
29516 wxPyEndAllowThreads(__tstate);
29517 if (PyErr_Occurred()) SWIG_fail;
29518 }
29519 {
29520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29521 }
29522 return resultobj;
29523 fail:
29524 return NULL;
29525 }
29526
29527
29528 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29529 PyObject *resultobj = 0;
29530 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29531 wxString result;
29532 void *argp1 = 0 ;
29533 int res1 = 0 ;
29534 PyObject *swig_obj[1] ;
29535
29536 if (!args) SWIG_fail;
29537 swig_obj[0] = args;
29538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29539 if (!SWIG_IsOK(res1)) {
29540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29541 }
29542 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29543 {
29544 PyThreadState* __tstate = wxPyBeginAllowThreads();
29545 result = ((wxAcceleratorEntry const *)arg1)->ToString();
29546 wxPyEndAllowThreads(__tstate);
29547 if (PyErr_Occurred()) SWIG_fail;
29548 }
29549 {
29550 #if wxUSE_UNICODE
29551 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29552 #else
29553 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29554 #endif
29555 }
29556 return resultobj;
29557 fail:
29558 return NULL;
29559 }
29560
29561
29562 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29563 PyObject *resultobj = 0;
29564 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29565 wxString *arg2 = 0 ;
29566 bool result;
29567 void *argp1 = 0 ;
29568 int res1 = 0 ;
29569 bool temp2 = false ;
29570 PyObject * obj0 = 0 ;
29571 PyObject * obj1 = 0 ;
29572 char * kwnames[] = {
29573 (char *) "self",(char *) "str", NULL
29574 };
29575
29576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
29577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29578 if (!SWIG_IsOK(res1)) {
29579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29580 }
29581 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29582 {
29583 arg2 = wxString_in_helper(obj1);
29584 if (arg2 == NULL) SWIG_fail;
29585 temp2 = true;
29586 }
29587 {
29588 PyThreadState* __tstate = wxPyBeginAllowThreads();
29589 result = (bool)(arg1)->FromString((wxString const &)*arg2);
29590 wxPyEndAllowThreads(__tstate);
29591 if (PyErr_Occurred()) SWIG_fail;
29592 }
29593 {
29594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29595 }
29596 {
29597 if (temp2)
29598 delete arg2;
29599 }
29600 return resultobj;
29601 fail:
29602 {
29603 if (temp2)
29604 delete arg2;
29605 }
29606 return NULL;
29607 }
29608
29609
29610 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29611 PyObject *obj;
29612 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29613 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29614 return SWIG_Py_Void();
29615 }
29616
29617 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29618 return SWIG_Python_InitShadowInstance(args);
29619 }
29620
29621 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29622 PyObject *resultobj = 0;
29623 int arg1 ;
29624 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29625 wxAcceleratorTable *result = 0 ;
29626 PyObject * obj0 = 0 ;
29627 char * kwnames[] = {
29628 (char *) "n", NULL
29629 };
29630
29631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29632 {
29633 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29634 if (arg2) arg1 = PyList_Size(obj0);
29635 else arg1 = 0;
29636 }
29637 {
29638 PyThreadState* __tstate = wxPyBeginAllowThreads();
29639 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29640 wxPyEndAllowThreads(__tstate);
29641 if (PyErr_Occurred()) SWIG_fail;
29642 }
29643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29644 return resultobj;
29645 fail:
29646 return NULL;
29647 }
29648
29649
29650 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29651 PyObject *resultobj = 0;
29652 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29653 void *argp1 = 0 ;
29654 int res1 = 0 ;
29655 PyObject *swig_obj[1] ;
29656
29657 if (!args) SWIG_fail;
29658 swig_obj[0] = args;
29659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29660 if (!SWIG_IsOK(res1)) {
29661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29662 }
29663 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29664 {
29665 PyThreadState* __tstate = wxPyBeginAllowThreads();
29666 delete arg1;
29667
29668 wxPyEndAllowThreads(__tstate);
29669 if (PyErr_Occurred()) SWIG_fail;
29670 }
29671 resultobj = SWIG_Py_Void();
29672 return resultobj;
29673 fail:
29674 return NULL;
29675 }
29676
29677
29678 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29679 PyObject *resultobj = 0;
29680 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29681 bool result;
29682 void *argp1 = 0 ;
29683 int res1 = 0 ;
29684 PyObject *swig_obj[1] ;
29685
29686 if (!args) SWIG_fail;
29687 swig_obj[0] = args;
29688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29689 if (!SWIG_IsOK(res1)) {
29690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29691 }
29692 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29693 {
29694 PyThreadState* __tstate = wxPyBeginAllowThreads();
29695 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29696 wxPyEndAllowThreads(__tstate);
29697 if (PyErr_Occurred()) SWIG_fail;
29698 }
29699 {
29700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29701 }
29702 return resultobj;
29703 fail:
29704 return NULL;
29705 }
29706
29707
29708 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29709 PyObject *obj;
29710 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29711 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29712 return SWIG_Py_Void();
29713 }
29714
29715 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29716 return SWIG_Python_InitShadowInstance(args);
29717 }
29718
29719 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29720 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29721 return 1;
29722 }
29723
29724
29725 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29726 PyObject *pyobj = 0;
29727
29728 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29729 return pyobj;
29730 }
29731
29732
29733 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29734 PyObject *resultobj = 0;
29735 wxString *arg1 = 0 ;
29736 wxAcceleratorEntry *result = 0 ;
29737 bool temp1 = false ;
29738 PyObject * obj0 = 0 ;
29739 char * kwnames[] = {
29740 (char *) "label", NULL
29741 };
29742
29743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29744 {
29745 arg1 = wxString_in_helper(obj0);
29746 if (arg1 == NULL) SWIG_fail;
29747 temp1 = true;
29748 }
29749 {
29750 PyThreadState* __tstate = wxPyBeginAllowThreads();
29751 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29752 wxPyEndAllowThreads(__tstate);
29753 if (PyErr_Occurred()) SWIG_fail;
29754 }
29755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29756 {
29757 if (temp1)
29758 delete arg1;
29759 }
29760 return resultobj;
29761 fail:
29762 {
29763 if (temp1)
29764 delete arg1;
29765 }
29766 return NULL;
29767 }
29768
29769
29770 SWIGINTERN int PanelNameStr_set(PyObject *) {
29771 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29772 return 1;
29773 }
29774
29775
29776 SWIGINTERN PyObject *PanelNameStr_get(void) {
29777 PyObject *pyobj = 0;
29778
29779 {
29780 #if wxUSE_UNICODE
29781 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29782 #else
29783 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29784 #endif
29785 }
29786 return pyobj;
29787 }
29788
29789
29790 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29791 PyObject *resultobj = 0;
29792 wxVisualAttributes *result = 0 ;
29793
29794 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29795 {
29796 PyThreadState* __tstate = wxPyBeginAllowThreads();
29797 result = (wxVisualAttributes *)new_wxVisualAttributes();
29798 wxPyEndAllowThreads(__tstate);
29799 if (PyErr_Occurred()) SWIG_fail;
29800 }
29801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29802 return resultobj;
29803 fail:
29804 return NULL;
29805 }
29806
29807
29808 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29809 PyObject *resultobj = 0;
29810 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29811 void *argp1 = 0 ;
29812 int res1 = 0 ;
29813 PyObject *swig_obj[1] ;
29814
29815 if (!args) SWIG_fail;
29816 swig_obj[0] = args;
29817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29818 if (!SWIG_IsOK(res1)) {
29819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29820 }
29821 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29822 {
29823 PyThreadState* __tstate = wxPyBeginAllowThreads();
29824 delete_wxVisualAttributes(arg1);
29825
29826 wxPyEndAllowThreads(__tstate);
29827 if (PyErr_Occurred()) SWIG_fail;
29828 }
29829 resultobj = SWIG_Py_Void();
29830 return resultobj;
29831 fail:
29832 return NULL;
29833 }
29834
29835
29836 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29837 PyObject *resultobj = 0;
29838 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29839 wxFont *arg2 = (wxFont *) 0 ;
29840 void *argp1 = 0 ;
29841 int res1 = 0 ;
29842 void *argp2 = 0 ;
29843 int res2 = 0 ;
29844 PyObject *swig_obj[2] ;
29845
29846 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29848 if (!SWIG_IsOK(res1)) {
29849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29850 }
29851 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29852 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29853 if (!SWIG_IsOK(res2)) {
29854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29855 }
29856 arg2 = reinterpret_cast< wxFont * >(argp2);
29857 if (arg1) (arg1)->font = *arg2;
29858
29859 resultobj = SWIG_Py_Void();
29860 return resultobj;
29861 fail:
29862 return NULL;
29863 }
29864
29865
29866 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29867 PyObject *resultobj = 0;
29868 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29869 wxFont *result = 0 ;
29870 void *argp1 = 0 ;
29871 int res1 = 0 ;
29872 PyObject *swig_obj[1] ;
29873
29874 if (!args) SWIG_fail;
29875 swig_obj[0] = args;
29876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29877 if (!SWIG_IsOK(res1)) {
29878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29879 }
29880 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29881 result = (wxFont *)& ((arg1)->font);
29882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29883 return resultobj;
29884 fail:
29885 return NULL;
29886 }
29887
29888
29889 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29890 PyObject *resultobj = 0;
29891 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29892 wxColour *arg2 = (wxColour *) 0 ;
29893 void *argp1 = 0 ;
29894 int res1 = 0 ;
29895 void *argp2 = 0 ;
29896 int res2 = 0 ;
29897 PyObject *swig_obj[2] ;
29898
29899 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29901 if (!SWIG_IsOK(res1)) {
29902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29903 }
29904 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29905 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29906 if (!SWIG_IsOK(res2)) {
29907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29908 }
29909 arg2 = reinterpret_cast< wxColour * >(argp2);
29910 if (arg1) (arg1)->colFg = *arg2;
29911
29912 resultobj = SWIG_Py_Void();
29913 return resultobj;
29914 fail:
29915 return NULL;
29916 }
29917
29918
29919 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29920 PyObject *resultobj = 0;
29921 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29922 wxColour *result = 0 ;
29923 void *argp1 = 0 ;
29924 int res1 = 0 ;
29925 PyObject *swig_obj[1] ;
29926
29927 if (!args) SWIG_fail;
29928 swig_obj[0] = args;
29929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29930 if (!SWIG_IsOK(res1)) {
29931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29932 }
29933 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29934 result = (wxColour *)& ((arg1)->colFg);
29935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29936 return resultobj;
29937 fail:
29938 return NULL;
29939 }
29940
29941
29942 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29943 PyObject *resultobj = 0;
29944 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29945 wxColour *arg2 = (wxColour *) 0 ;
29946 void *argp1 = 0 ;
29947 int res1 = 0 ;
29948 void *argp2 = 0 ;
29949 int res2 = 0 ;
29950 PyObject *swig_obj[2] ;
29951
29952 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29954 if (!SWIG_IsOK(res1)) {
29955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29956 }
29957 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29958 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29959 if (!SWIG_IsOK(res2)) {
29960 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29961 }
29962 arg2 = reinterpret_cast< wxColour * >(argp2);
29963 if (arg1) (arg1)->colBg = *arg2;
29964
29965 resultobj = SWIG_Py_Void();
29966 return resultobj;
29967 fail:
29968 return NULL;
29969 }
29970
29971
29972 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29973 PyObject *resultobj = 0;
29974 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29975 wxColour *result = 0 ;
29976 void *argp1 = 0 ;
29977 int res1 = 0 ;
29978 PyObject *swig_obj[1] ;
29979
29980 if (!args) SWIG_fail;
29981 swig_obj[0] = args;
29982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29983 if (!SWIG_IsOK(res1)) {
29984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29985 }
29986 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29987 result = (wxColour *)& ((arg1)->colBg);
29988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29989 return resultobj;
29990 fail:
29991 return NULL;
29992 }
29993
29994
29995 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29996 PyObject *obj;
29997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29998 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29999 return SWIG_Py_Void();
30000 }
30001
30002 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30003 return SWIG_Python_InitShadowInstance(args);
30004 }
30005
30006 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30007 PyObject *resultobj = 0;
30008 wxWindow *arg1 = (wxWindow *) 0 ;
30009 int arg2 = (int) (int)-1 ;
30010 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30011 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30012 wxSize const &arg4_defvalue = wxDefaultSize ;
30013 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30014 long arg5 = (long) 0 ;
30015 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30016 wxString *arg6 = (wxString *) &arg6_defvalue ;
30017 wxWindow *result = 0 ;
30018 void *argp1 = 0 ;
30019 int res1 = 0 ;
30020 int val2 ;
30021 int ecode2 = 0 ;
30022 wxPoint temp3 ;
30023 wxSize temp4 ;
30024 long val5 ;
30025 int ecode5 = 0 ;
30026 bool temp6 = false ;
30027 PyObject * obj0 = 0 ;
30028 PyObject * obj1 = 0 ;
30029 PyObject * obj2 = 0 ;
30030 PyObject * obj3 = 0 ;
30031 PyObject * obj4 = 0 ;
30032 PyObject * obj5 = 0 ;
30033 char * kwnames[] = {
30034 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30035 };
30036
30037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30039 if (!SWIG_IsOK(res1)) {
30040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30041 }
30042 arg1 = reinterpret_cast< wxWindow * >(argp1);
30043 if (obj1) {
30044 ecode2 = SWIG_AsVal_int(obj1, &val2);
30045 if (!SWIG_IsOK(ecode2)) {
30046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30047 }
30048 arg2 = static_cast< int >(val2);
30049 }
30050 if (obj2) {
30051 {
30052 arg3 = &temp3;
30053 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30054 }
30055 }
30056 if (obj3) {
30057 {
30058 arg4 = &temp4;
30059 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30060 }
30061 }
30062 if (obj4) {
30063 ecode5 = SWIG_AsVal_long(obj4, &val5);
30064 if (!SWIG_IsOK(ecode5)) {
30065 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30066 }
30067 arg5 = static_cast< long >(val5);
30068 }
30069 if (obj5) {
30070 {
30071 arg6 = wxString_in_helper(obj5);
30072 if (arg6 == NULL) SWIG_fail;
30073 temp6 = true;
30074 }
30075 }
30076 {
30077 if (!wxPyCheckForApp()) SWIG_fail;
30078 PyThreadState* __tstate = wxPyBeginAllowThreads();
30079 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30080 wxPyEndAllowThreads(__tstate);
30081 if (PyErr_Occurred()) SWIG_fail;
30082 }
30083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30084 {
30085 if (temp6)
30086 delete arg6;
30087 }
30088 return resultobj;
30089 fail:
30090 {
30091 if (temp6)
30092 delete arg6;
30093 }
30094 return NULL;
30095 }
30096
30097
30098 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30099 PyObject *resultobj = 0;
30100 wxWindow *result = 0 ;
30101
30102 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30103 {
30104 if (!wxPyCheckForApp()) SWIG_fail;
30105 PyThreadState* __tstate = wxPyBeginAllowThreads();
30106 result = (wxWindow *)new wxWindow();
30107 wxPyEndAllowThreads(__tstate);
30108 if (PyErr_Occurred()) SWIG_fail;
30109 }
30110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30111 return resultobj;
30112 fail:
30113 return NULL;
30114 }
30115
30116
30117 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30118 PyObject *resultobj = 0;
30119 wxWindow *arg1 = (wxWindow *) 0 ;
30120 wxWindow *arg2 = (wxWindow *) 0 ;
30121 int arg3 = (int) (int)-1 ;
30122 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30123 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30124 wxSize const &arg5_defvalue = wxDefaultSize ;
30125 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30126 long arg6 = (long) 0 ;
30127 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30128 wxString *arg7 = (wxString *) &arg7_defvalue ;
30129 bool result;
30130 void *argp1 = 0 ;
30131 int res1 = 0 ;
30132 void *argp2 = 0 ;
30133 int res2 = 0 ;
30134 int val3 ;
30135 int ecode3 = 0 ;
30136 wxPoint temp4 ;
30137 wxSize temp5 ;
30138 long val6 ;
30139 int ecode6 = 0 ;
30140 bool temp7 = false ;
30141 PyObject * obj0 = 0 ;
30142 PyObject * obj1 = 0 ;
30143 PyObject * obj2 = 0 ;
30144 PyObject * obj3 = 0 ;
30145 PyObject * obj4 = 0 ;
30146 PyObject * obj5 = 0 ;
30147 PyObject * obj6 = 0 ;
30148 char * kwnames[] = {
30149 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30150 };
30151
30152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30154 if (!SWIG_IsOK(res1)) {
30155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30156 }
30157 arg1 = reinterpret_cast< wxWindow * >(argp1);
30158 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30159 if (!SWIG_IsOK(res2)) {
30160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30161 }
30162 arg2 = reinterpret_cast< wxWindow * >(argp2);
30163 if (obj2) {
30164 ecode3 = SWIG_AsVal_int(obj2, &val3);
30165 if (!SWIG_IsOK(ecode3)) {
30166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30167 }
30168 arg3 = static_cast< int >(val3);
30169 }
30170 if (obj3) {
30171 {
30172 arg4 = &temp4;
30173 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30174 }
30175 }
30176 if (obj4) {
30177 {
30178 arg5 = &temp5;
30179 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30180 }
30181 }
30182 if (obj5) {
30183 ecode6 = SWIG_AsVal_long(obj5, &val6);
30184 if (!SWIG_IsOK(ecode6)) {
30185 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30186 }
30187 arg6 = static_cast< long >(val6);
30188 }
30189 if (obj6) {
30190 {
30191 arg7 = wxString_in_helper(obj6);
30192 if (arg7 == NULL) SWIG_fail;
30193 temp7 = true;
30194 }
30195 }
30196 {
30197 PyThreadState* __tstate = wxPyBeginAllowThreads();
30198 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30199 wxPyEndAllowThreads(__tstate);
30200 if (PyErr_Occurred()) SWIG_fail;
30201 }
30202 {
30203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30204 }
30205 {
30206 if (temp7)
30207 delete arg7;
30208 }
30209 return resultobj;
30210 fail:
30211 {
30212 if (temp7)
30213 delete arg7;
30214 }
30215 return NULL;
30216 }
30217
30218
30219 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30220 PyObject *resultobj = 0;
30221 wxWindow *arg1 = (wxWindow *) 0 ;
30222 bool arg2 = (bool) false ;
30223 bool result;
30224 void *argp1 = 0 ;
30225 int res1 = 0 ;
30226 bool val2 ;
30227 int ecode2 = 0 ;
30228 PyObject * obj0 = 0 ;
30229 PyObject * obj1 = 0 ;
30230 char * kwnames[] = {
30231 (char *) "self",(char *) "force", NULL
30232 };
30233
30234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30236 if (!SWIG_IsOK(res1)) {
30237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30238 }
30239 arg1 = reinterpret_cast< wxWindow * >(argp1);
30240 if (obj1) {
30241 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30242 if (!SWIG_IsOK(ecode2)) {
30243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30244 }
30245 arg2 = static_cast< bool >(val2);
30246 }
30247 {
30248 PyThreadState* __tstate = wxPyBeginAllowThreads();
30249 result = (bool)(arg1)->Close(arg2);
30250 wxPyEndAllowThreads(__tstate);
30251 if (PyErr_Occurred()) SWIG_fail;
30252 }
30253 {
30254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30255 }
30256 return resultobj;
30257 fail:
30258 return NULL;
30259 }
30260
30261
30262 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30263 PyObject *resultobj = 0;
30264 wxWindow *arg1 = (wxWindow *) 0 ;
30265 bool result;
30266 void *argp1 = 0 ;
30267 int res1 = 0 ;
30268 PyObject *swig_obj[1] ;
30269
30270 if (!args) SWIG_fail;
30271 swig_obj[0] = args;
30272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30273 if (!SWIG_IsOK(res1)) {
30274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30275 }
30276 arg1 = reinterpret_cast< wxWindow * >(argp1);
30277 {
30278 PyThreadState* __tstate = wxPyBeginAllowThreads();
30279 result = (bool)(arg1)->Destroy();
30280 wxPyEndAllowThreads(__tstate);
30281 if (PyErr_Occurred()) SWIG_fail;
30282 }
30283 {
30284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30285 }
30286 return resultobj;
30287 fail:
30288 return NULL;
30289 }
30290
30291
30292 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30293 PyObject *resultobj = 0;
30294 wxWindow *arg1 = (wxWindow *) 0 ;
30295 bool result;
30296 void *argp1 = 0 ;
30297 int res1 = 0 ;
30298 PyObject *swig_obj[1] ;
30299
30300 if (!args) SWIG_fail;
30301 swig_obj[0] = args;
30302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30303 if (!SWIG_IsOK(res1)) {
30304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30305 }
30306 arg1 = reinterpret_cast< wxWindow * >(argp1);
30307 {
30308 PyThreadState* __tstate = wxPyBeginAllowThreads();
30309 result = (bool)(arg1)->DestroyChildren();
30310 wxPyEndAllowThreads(__tstate);
30311 if (PyErr_Occurred()) SWIG_fail;
30312 }
30313 {
30314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30315 }
30316 return resultobj;
30317 fail:
30318 return NULL;
30319 }
30320
30321
30322 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30323 PyObject *resultobj = 0;
30324 wxWindow *arg1 = (wxWindow *) 0 ;
30325 bool result;
30326 void *argp1 = 0 ;
30327 int res1 = 0 ;
30328 PyObject *swig_obj[1] ;
30329
30330 if (!args) SWIG_fail;
30331 swig_obj[0] = args;
30332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30333 if (!SWIG_IsOK(res1)) {
30334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30335 }
30336 arg1 = reinterpret_cast< wxWindow * >(argp1);
30337 {
30338 PyThreadState* __tstate = wxPyBeginAllowThreads();
30339 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30340 wxPyEndAllowThreads(__tstate);
30341 if (PyErr_Occurred()) SWIG_fail;
30342 }
30343 {
30344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30345 }
30346 return resultobj;
30347 fail:
30348 return NULL;
30349 }
30350
30351
30352 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30353 PyObject *resultobj = 0;
30354 wxWindow *arg1 = (wxWindow *) 0 ;
30355 wxString *arg2 = 0 ;
30356 void *argp1 = 0 ;
30357 int res1 = 0 ;
30358 bool temp2 = false ;
30359 PyObject * obj0 = 0 ;
30360 PyObject * obj1 = 0 ;
30361 char * kwnames[] = {
30362 (char *) "self",(char *) "label", NULL
30363 };
30364
30365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30367 if (!SWIG_IsOK(res1)) {
30368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30369 }
30370 arg1 = reinterpret_cast< wxWindow * >(argp1);
30371 {
30372 arg2 = wxString_in_helper(obj1);
30373 if (arg2 == NULL) SWIG_fail;
30374 temp2 = true;
30375 }
30376 {
30377 PyThreadState* __tstate = wxPyBeginAllowThreads();
30378 (arg1)->SetLabel((wxString const &)*arg2);
30379 wxPyEndAllowThreads(__tstate);
30380 if (PyErr_Occurred()) SWIG_fail;
30381 }
30382 resultobj = SWIG_Py_Void();
30383 {
30384 if (temp2)
30385 delete arg2;
30386 }
30387 return resultobj;
30388 fail:
30389 {
30390 if (temp2)
30391 delete arg2;
30392 }
30393 return NULL;
30394 }
30395
30396
30397 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30398 PyObject *resultobj = 0;
30399 wxWindow *arg1 = (wxWindow *) 0 ;
30400 wxString result;
30401 void *argp1 = 0 ;
30402 int res1 = 0 ;
30403 PyObject *swig_obj[1] ;
30404
30405 if (!args) SWIG_fail;
30406 swig_obj[0] = args;
30407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30408 if (!SWIG_IsOK(res1)) {
30409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30410 }
30411 arg1 = reinterpret_cast< wxWindow * >(argp1);
30412 {
30413 PyThreadState* __tstate = wxPyBeginAllowThreads();
30414 result = ((wxWindow const *)arg1)->GetLabel();
30415 wxPyEndAllowThreads(__tstate);
30416 if (PyErr_Occurred()) SWIG_fail;
30417 }
30418 {
30419 #if wxUSE_UNICODE
30420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30421 #else
30422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30423 #endif
30424 }
30425 return resultobj;
30426 fail:
30427 return NULL;
30428 }
30429
30430
30431 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30432 PyObject *resultobj = 0;
30433 wxWindow *arg1 = (wxWindow *) 0 ;
30434 wxString *arg2 = 0 ;
30435 void *argp1 = 0 ;
30436 int res1 = 0 ;
30437 bool temp2 = false ;
30438 PyObject * obj0 = 0 ;
30439 PyObject * obj1 = 0 ;
30440 char * kwnames[] = {
30441 (char *) "self",(char *) "name", NULL
30442 };
30443
30444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30446 if (!SWIG_IsOK(res1)) {
30447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30448 }
30449 arg1 = reinterpret_cast< wxWindow * >(argp1);
30450 {
30451 arg2 = wxString_in_helper(obj1);
30452 if (arg2 == NULL) SWIG_fail;
30453 temp2 = true;
30454 }
30455 {
30456 PyThreadState* __tstate = wxPyBeginAllowThreads();
30457 (arg1)->SetName((wxString const &)*arg2);
30458 wxPyEndAllowThreads(__tstate);
30459 if (PyErr_Occurred()) SWIG_fail;
30460 }
30461 resultobj = SWIG_Py_Void();
30462 {
30463 if (temp2)
30464 delete arg2;
30465 }
30466 return resultobj;
30467 fail:
30468 {
30469 if (temp2)
30470 delete arg2;
30471 }
30472 return NULL;
30473 }
30474
30475
30476 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30477 PyObject *resultobj = 0;
30478 wxWindow *arg1 = (wxWindow *) 0 ;
30479 wxString result;
30480 void *argp1 = 0 ;
30481 int res1 = 0 ;
30482 PyObject *swig_obj[1] ;
30483
30484 if (!args) SWIG_fail;
30485 swig_obj[0] = args;
30486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30487 if (!SWIG_IsOK(res1)) {
30488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30489 }
30490 arg1 = reinterpret_cast< wxWindow * >(argp1);
30491 {
30492 PyThreadState* __tstate = wxPyBeginAllowThreads();
30493 result = ((wxWindow const *)arg1)->GetName();
30494 wxPyEndAllowThreads(__tstate);
30495 if (PyErr_Occurred()) SWIG_fail;
30496 }
30497 {
30498 #if wxUSE_UNICODE
30499 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30500 #else
30501 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30502 #endif
30503 }
30504 return resultobj;
30505 fail:
30506 return NULL;
30507 }
30508
30509
30510 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30511 PyObject *resultobj = 0;
30512 wxWindow *arg1 = (wxWindow *) 0 ;
30513 wxWindowVariant arg2 ;
30514 void *argp1 = 0 ;
30515 int res1 = 0 ;
30516 int val2 ;
30517 int ecode2 = 0 ;
30518 PyObject * obj0 = 0 ;
30519 PyObject * obj1 = 0 ;
30520 char * kwnames[] = {
30521 (char *) "self",(char *) "variant", NULL
30522 };
30523
30524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30526 if (!SWIG_IsOK(res1)) {
30527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30528 }
30529 arg1 = reinterpret_cast< wxWindow * >(argp1);
30530 ecode2 = SWIG_AsVal_int(obj1, &val2);
30531 if (!SWIG_IsOK(ecode2)) {
30532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30533 }
30534 arg2 = static_cast< wxWindowVariant >(val2);
30535 {
30536 PyThreadState* __tstate = wxPyBeginAllowThreads();
30537 (arg1)->SetWindowVariant(arg2);
30538 wxPyEndAllowThreads(__tstate);
30539 if (PyErr_Occurred()) SWIG_fail;
30540 }
30541 resultobj = SWIG_Py_Void();
30542 return resultobj;
30543 fail:
30544 return NULL;
30545 }
30546
30547
30548 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30549 PyObject *resultobj = 0;
30550 wxWindow *arg1 = (wxWindow *) 0 ;
30551 wxWindowVariant result;
30552 void *argp1 = 0 ;
30553 int res1 = 0 ;
30554 PyObject *swig_obj[1] ;
30555
30556 if (!args) SWIG_fail;
30557 swig_obj[0] = args;
30558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30559 if (!SWIG_IsOK(res1)) {
30560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30561 }
30562 arg1 = reinterpret_cast< wxWindow * >(argp1);
30563 {
30564 PyThreadState* __tstate = wxPyBeginAllowThreads();
30565 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30566 wxPyEndAllowThreads(__tstate);
30567 if (PyErr_Occurred()) SWIG_fail;
30568 }
30569 resultobj = SWIG_From_int(static_cast< int >(result));
30570 return resultobj;
30571 fail:
30572 return NULL;
30573 }
30574
30575
30576 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30577 PyObject *resultobj = 0;
30578 wxWindow *arg1 = (wxWindow *) 0 ;
30579 int arg2 ;
30580 void *argp1 = 0 ;
30581 int res1 = 0 ;
30582 int val2 ;
30583 int ecode2 = 0 ;
30584 PyObject * obj0 = 0 ;
30585 PyObject * obj1 = 0 ;
30586 char * kwnames[] = {
30587 (char *) "self",(char *) "winid", NULL
30588 };
30589
30590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30592 if (!SWIG_IsOK(res1)) {
30593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30594 }
30595 arg1 = reinterpret_cast< wxWindow * >(argp1);
30596 ecode2 = SWIG_AsVal_int(obj1, &val2);
30597 if (!SWIG_IsOK(ecode2)) {
30598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30599 }
30600 arg2 = static_cast< int >(val2);
30601 {
30602 PyThreadState* __tstate = wxPyBeginAllowThreads();
30603 (arg1)->SetId(arg2);
30604 wxPyEndAllowThreads(__tstate);
30605 if (PyErr_Occurred()) SWIG_fail;
30606 }
30607 resultobj = SWIG_Py_Void();
30608 return resultobj;
30609 fail:
30610 return NULL;
30611 }
30612
30613
30614 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30615 PyObject *resultobj = 0;
30616 wxWindow *arg1 = (wxWindow *) 0 ;
30617 int result;
30618 void *argp1 = 0 ;
30619 int res1 = 0 ;
30620 PyObject *swig_obj[1] ;
30621
30622 if (!args) SWIG_fail;
30623 swig_obj[0] = args;
30624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30625 if (!SWIG_IsOK(res1)) {
30626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30627 }
30628 arg1 = reinterpret_cast< wxWindow * >(argp1);
30629 {
30630 PyThreadState* __tstate = wxPyBeginAllowThreads();
30631 result = (int)((wxWindow const *)arg1)->GetId();
30632 wxPyEndAllowThreads(__tstate);
30633 if (PyErr_Occurred()) SWIG_fail;
30634 }
30635 resultobj = SWIG_From_int(static_cast< int >(result));
30636 return resultobj;
30637 fail:
30638 return NULL;
30639 }
30640
30641
30642 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30643 PyObject *resultobj = 0;
30644 int result;
30645
30646 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30647 {
30648 PyThreadState* __tstate = wxPyBeginAllowThreads();
30649 result = (int)wxWindow::NewControlId();
30650 wxPyEndAllowThreads(__tstate);
30651 if (PyErr_Occurred()) SWIG_fail;
30652 }
30653 resultobj = SWIG_From_int(static_cast< int >(result));
30654 return resultobj;
30655 fail:
30656 return NULL;
30657 }
30658
30659
30660 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30661 PyObject *resultobj = 0;
30662 int arg1 ;
30663 int result;
30664 int val1 ;
30665 int ecode1 = 0 ;
30666 PyObject * obj0 = 0 ;
30667 char * kwnames[] = {
30668 (char *) "winid", NULL
30669 };
30670
30671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30672 ecode1 = SWIG_AsVal_int(obj0, &val1);
30673 if (!SWIG_IsOK(ecode1)) {
30674 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30675 }
30676 arg1 = static_cast< int >(val1);
30677 {
30678 PyThreadState* __tstate = wxPyBeginAllowThreads();
30679 result = (int)wxWindow::NextControlId(arg1);
30680 wxPyEndAllowThreads(__tstate);
30681 if (PyErr_Occurred()) SWIG_fail;
30682 }
30683 resultobj = SWIG_From_int(static_cast< int >(result));
30684 return resultobj;
30685 fail:
30686 return NULL;
30687 }
30688
30689
30690 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30691 PyObject *resultobj = 0;
30692 int arg1 ;
30693 int result;
30694 int val1 ;
30695 int ecode1 = 0 ;
30696 PyObject * obj0 = 0 ;
30697 char * kwnames[] = {
30698 (char *) "winid", NULL
30699 };
30700
30701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30702 ecode1 = SWIG_AsVal_int(obj0, &val1);
30703 if (!SWIG_IsOK(ecode1)) {
30704 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30705 }
30706 arg1 = static_cast< int >(val1);
30707 {
30708 PyThreadState* __tstate = wxPyBeginAllowThreads();
30709 result = (int)wxWindow::PrevControlId(arg1);
30710 wxPyEndAllowThreads(__tstate);
30711 if (PyErr_Occurred()) SWIG_fail;
30712 }
30713 resultobj = SWIG_From_int(static_cast< int >(result));
30714 return resultobj;
30715 fail:
30716 return NULL;
30717 }
30718
30719
30720 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30721 PyObject *resultobj = 0;
30722 wxWindow *arg1 = (wxWindow *) 0 ;
30723 wxLayoutDirection result;
30724 void *argp1 = 0 ;
30725 int res1 = 0 ;
30726 PyObject *swig_obj[1] ;
30727
30728 if (!args) SWIG_fail;
30729 swig_obj[0] = args;
30730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30731 if (!SWIG_IsOK(res1)) {
30732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30733 }
30734 arg1 = reinterpret_cast< wxWindow * >(argp1);
30735 {
30736 PyThreadState* __tstate = wxPyBeginAllowThreads();
30737 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
30738 wxPyEndAllowThreads(__tstate);
30739 if (PyErr_Occurred()) SWIG_fail;
30740 }
30741 resultobj = SWIG_From_int(static_cast< int >(result));
30742 return resultobj;
30743 fail:
30744 return NULL;
30745 }
30746
30747
30748 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30749 PyObject *resultobj = 0;
30750 wxWindow *arg1 = (wxWindow *) 0 ;
30751 wxLayoutDirection arg2 ;
30752 void *argp1 = 0 ;
30753 int res1 = 0 ;
30754 int val2 ;
30755 int ecode2 = 0 ;
30756 PyObject * obj0 = 0 ;
30757 PyObject * obj1 = 0 ;
30758 char * kwnames[] = {
30759 (char *) "self",(char *) "dir", NULL
30760 };
30761
30762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
30763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30764 if (!SWIG_IsOK(res1)) {
30765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
30766 }
30767 arg1 = reinterpret_cast< wxWindow * >(argp1);
30768 ecode2 = SWIG_AsVal_int(obj1, &val2);
30769 if (!SWIG_IsOK(ecode2)) {
30770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
30771 }
30772 arg2 = static_cast< wxLayoutDirection >(val2);
30773 {
30774 PyThreadState* __tstate = wxPyBeginAllowThreads();
30775 (arg1)->SetLayoutDirection(arg2);
30776 wxPyEndAllowThreads(__tstate);
30777 if (PyErr_Occurred()) SWIG_fail;
30778 }
30779 resultobj = SWIG_Py_Void();
30780 return resultobj;
30781 fail:
30782 return NULL;
30783 }
30784
30785
30786 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30787 PyObject *resultobj = 0;
30788 wxWindow *arg1 = (wxWindow *) 0 ;
30789 int arg2 ;
30790 int arg3 ;
30791 int arg4 ;
30792 int result;
30793 void *argp1 = 0 ;
30794 int res1 = 0 ;
30795 int val2 ;
30796 int ecode2 = 0 ;
30797 int val3 ;
30798 int ecode3 = 0 ;
30799 int val4 ;
30800 int ecode4 = 0 ;
30801 PyObject * obj0 = 0 ;
30802 PyObject * obj1 = 0 ;
30803 PyObject * obj2 = 0 ;
30804 PyObject * obj3 = 0 ;
30805 char * kwnames[] = {
30806 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
30807 };
30808
30809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30811 if (!SWIG_IsOK(res1)) {
30812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30813 }
30814 arg1 = reinterpret_cast< wxWindow * >(argp1);
30815 ecode2 = SWIG_AsVal_int(obj1, &val2);
30816 if (!SWIG_IsOK(ecode2)) {
30817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
30818 }
30819 arg2 = static_cast< int >(val2);
30820 ecode3 = SWIG_AsVal_int(obj2, &val3);
30821 if (!SWIG_IsOK(ecode3)) {
30822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
30823 }
30824 arg3 = static_cast< int >(val3);
30825 ecode4 = SWIG_AsVal_int(obj3, &val4);
30826 if (!SWIG_IsOK(ecode4)) {
30827 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
30828 }
30829 arg4 = static_cast< int >(val4);
30830 {
30831 PyThreadState* __tstate = wxPyBeginAllowThreads();
30832 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
30833 wxPyEndAllowThreads(__tstate);
30834 if (PyErr_Occurred()) SWIG_fail;
30835 }
30836 resultobj = SWIG_From_int(static_cast< int >(result));
30837 return resultobj;
30838 fail:
30839 return NULL;
30840 }
30841
30842
30843 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30844 PyObject *resultobj = 0;
30845 wxWindow *arg1 = (wxWindow *) 0 ;
30846 wxSize *arg2 = 0 ;
30847 void *argp1 = 0 ;
30848 int res1 = 0 ;
30849 wxSize temp2 ;
30850 PyObject * obj0 = 0 ;
30851 PyObject * obj1 = 0 ;
30852 char * kwnames[] = {
30853 (char *) "self",(char *) "size", NULL
30854 };
30855
30856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30858 if (!SWIG_IsOK(res1)) {
30859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30860 }
30861 arg1 = reinterpret_cast< wxWindow * >(argp1);
30862 {
30863 arg2 = &temp2;
30864 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30865 }
30866 {
30867 PyThreadState* __tstate = wxPyBeginAllowThreads();
30868 (arg1)->SetSize((wxSize const &)*arg2);
30869 wxPyEndAllowThreads(__tstate);
30870 if (PyErr_Occurred()) SWIG_fail;
30871 }
30872 resultobj = SWIG_Py_Void();
30873 return resultobj;
30874 fail:
30875 return NULL;
30876 }
30877
30878
30879 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30880 PyObject *resultobj = 0;
30881 wxWindow *arg1 = (wxWindow *) 0 ;
30882 int arg2 ;
30883 int arg3 ;
30884 int arg4 ;
30885 int arg5 ;
30886 int arg6 = (int) wxSIZE_AUTO ;
30887 void *argp1 = 0 ;
30888 int res1 = 0 ;
30889 int val2 ;
30890 int ecode2 = 0 ;
30891 int val3 ;
30892 int ecode3 = 0 ;
30893 int val4 ;
30894 int ecode4 = 0 ;
30895 int val5 ;
30896 int ecode5 = 0 ;
30897 int val6 ;
30898 int ecode6 = 0 ;
30899 PyObject * obj0 = 0 ;
30900 PyObject * obj1 = 0 ;
30901 PyObject * obj2 = 0 ;
30902 PyObject * obj3 = 0 ;
30903 PyObject * obj4 = 0 ;
30904 PyObject * obj5 = 0 ;
30905 char * kwnames[] = {
30906 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30907 };
30908
30909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30911 if (!SWIG_IsOK(res1)) {
30912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30913 }
30914 arg1 = reinterpret_cast< wxWindow * >(argp1);
30915 ecode2 = SWIG_AsVal_int(obj1, &val2);
30916 if (!SWIG_IsOK(ecode2)) {
30917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30918 }
30919 arg2 = static_cast< int >(val2);
30920 ecode3 = SWIG_AsVal_int(obj2, &val3);
30921 if (!SWIG_IsOK(ecode3)) {
30922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30923 }
30924 arg3 = static_cast< int >(val3);
30925 ecode4 = SWIG_AsVal_int(obj3, &val4);
30926 if (!SWIG_IsOK(ecode4)) {
30927 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30928 }
30929 arg4 = static_cast< int >(val4);
30930 ecode5 = SWIG_AsVal_int(obj4, &val5);
30931 if (!SWIG_IsOK(ecode5)) {
30932 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30933 }
30934 arg5 = static_cast< int >(val5);
30935 if (obj5) {
30936 ecode6 = SWIG_AsVal_int(obj5, &val6);
30937 if (!SWIG_IsOK(ecode6)) {
30938 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30939 }
30940 arg6 = static_cast< int >(val6);
30941 }
30942 {
30943 PyThreadState* __tstate = wxPyBeginAllowThreads();
30944 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30945 wxPyEndAllowThreads(__tstate);
30946 if (PyErr_Occurred()) SWIG_fail;
30947 }
30948 resultobj = SWIG_Py_Void();
30949 return resultobj;
30950 fail:
30951 return NULL;
30952 }
30953
30954
30955 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30956 PyObject *resultobj = 0;
30957 wxWindow *arg1 = (wxWindow *) 0 ;
30958 wxRect *arg2 = 0 ;
30959 int arg3 = (int) wxSIZE_AUTO ;
30960 void *argp1 = 0 ;
30961 int res1 = 0 ;
30962 wxRect temp2 ;
30963 int val3 ;
30964 int ecode3 = 0 ;
30965 PyObject * obj0 = 0 ;
30966 PyObject * obj1 = 0 ;
30967 PyObject * obj2 = 0 ;
30968 char * kwnames[] = {
30969 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30970 };
30971
30972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30974 if (!SWIG_IsOK(res1)) {
30975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30976 }
30977 arg1 = reinterpret_cast< wxWindow * >(argp1);
30978 {
30979 arg2 = &temp2;
30980 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30981 }
30982 if (obj2) {
30983 ecode3 = SWIG_AsVal_int(obj2, &val3);
30984 if (!SWIG_IsOK(ecode3)) {
30985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30986 }
30987 arg3 = static_cast< int >(val3);
30988 }
30989 {
30990 PyThreadState* __tstate = wxPyBeginAllowThreads();
30991 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30992 wxPyEndAllowThreads(__tstate);
30993 if (PyErr_Occurred()) SWIG_fail;
30994 }
30995 resultobj = SWIG_Py_Void();
30996 return resultobj;
30997 fail:
30998 return NULL;
30999 }
31000
31001
31002 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31003 PyObject *resultobj = 0;
31004 wxWindow *arg1 = (wxWindow *) 0 ;
31005 int arg2 ;
31006 int arg3 ;
31007 void *argp1 = 0 ;
31008 int res1 = 0 ;
31009 int val2 ;
31010 int ecode2 = 0 ;
31011 int val3 ;
31012 int ecode3 = 0 ;
31013 PyObject * obj0 = 0 ;
31014 PyObject * obj1 = 0 ;
31015 PyObject * obj2 = 0 ;
31016 char * kwnames[] = {
31017 (char *) "self",(char *) "width",(char *) "height", NULL
31018 };
31019
31020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31022 if (!SWIG_IsOK(res1)) {
31023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31024 }
31025 arg1 = reinterpret_cast< wxWindow * >(argp1);
31026 ecode2 = SWIG_AsVal_int(obj1, &val2);
31027 if (!SWIG_IsOK(ecode2)) {
31028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31029 }
31030 arg2 = static_cast< int >(val2);
31031 ecode3 = SWIG_AsVal_int(obj2, &val3);
31032 if (!SWIG_IsOK(ecode3)) {
31033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31034 }
31035 arg3 = static_cast< int >(val3);
31036 {
31037 PyThreadState* __tstate = wxPyBeginAllowThreads();
31038 (arg1)->SetSize(arg2,arg3);
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 resultobj = SWIG_Py_Void();
31043 return resultobj;
31044 fail:
31045 return NULL;
31046 }
31047
31048
31049 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31050 PyObject *resultobj = 0;
31051 wxWindow *arg1 = (wxWindow *) 0 ;
31052 wxPoint *arg2 = 0 ;
31053 int arg3 = (int) wxSIZE_USE_EXISTING ;
31054 void *argp1 = 0 ;
31055 int res1 = 0 ;
31056 wxPoint temp2 ;
31057 int val3 ;
31058 int ecode3 = 0 ;
31059 PyObject * obj0 = 0 ;
31060 PyObject * obj1 = 0 ;
31061 PyObject * obj2 = 0 ;
31062 char * kwnames[] = {
31063 (char *) "self",(char *) "pt",(char *) "flags", NULL
31064 };
31065
31066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31068 if (!SWIG_IsOK(res1)) {
31069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31070 }
31071 arg1 = reinterpret_cast< wxWindow * >(argp1);
31072 {
31073 arg2 = &temp2;
31074 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31075 }
31076 if (obj2) {
31077 ecode3 = SWIG_AsVal_int(obj2, &val3);
31078 if (!SWIG_IsOK(ecode3)) {
31079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31080 }
31081 arg3 = static_cast< int >(val3);
31082 }
31083 {
31084 PyThreadState* __tstate = wxPyBeginAllowThreads();
31085 (arg1)->Move((wxPoint const &)*arg2,arg3);
31086 wxPyEndAllowThreads(__tstate);
31087 if (PyErr_Occurred()) SWIG_fail;
31088 }
31089 resultobj = SWIG_Py_Void();
31090 return resultobj;
31091 fail:
31092 return NULL;
31093 }
31094
31095
31096 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31097 PyObject *resultobj = 0;
31098 wxWindow *arg1 = (wxWindow *) 0 ;
31099 int arg2 ;
31100 int arg3 ;
31101 int arg4 = (int) wxSIZE_USE_EXISTING ;
31102 void *argp1 = 0 ;
31103 int res1 = 0 ;
31104 int val2 ;
31105 int ecode2 = 0 ;
31106 int val3 ;
31107 int ecode3 = 0 ;
31108 int val4 ;
31109 int ecode4 = 0 ;
31110 PyObject * obj0 = 0 ;
31111 PyObject * obj1 = 0 ;
31112 PyObject * obj2 = 0 ;
31113 PyObject * obj3 = 0 ;
31114 char * kwnames[] = {
31115 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31116 };
31117
31118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31120 if (!SWIG_IsOK(res1)) {
31121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31122 }
31123 arg1 = reinterpret_cast< wxWindow * >(argp1);
31124 ecode2 = SWIG_AsVal_int(obj1, &val2);
31125 if (!SWIG_IsOK(ecode2)) {
31126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31127 }
31128 arg2 = static_cast< int >(val2);
31129 ecode3 = SWIG_AsVal_int(obj2, &val3);
31130 if (!SWIG_IsOK(ecode3)) {
31131 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31132 }
31133 arg3 = static_cast< int >(val3);
31134 if (obj3) {
31135 ecode4 = SWIG_AsVal_int(obj3, &val4);
31136 if (!SWIG_IsOK(ecode4)) {
31137 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31138 }
31139 arg4 = static_cast< int >(val4);
31140 }
31141 {
31142 PyThreadState* __tstate = wxPyBeginAllowThreads();
31143 (arg1)->Move(arg2,arg3,arg4);
31144 wxPyEndAllowThreads(__tstate);
31145 if (PyErr_Occurred()) SWIG_fail;
31146 }
31147 resultobj = SWIG_Py_Void();
31148 return resultobj;
31149 fail:
31150 return NULL;
31151 }
31152
31153
31154 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31155 PyObject *resultobj = 0;
31156 wxWindow *arg1 = (wxWindow *) 0 ;
31157 wxSize const &arg2_defvalue = wxDefaultSize ;
31158 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31159 void *argp1 = 0 ;
31160 int res1 = 0 ;
31161 wxSize temp2 ;
31162 PyObject * obj0 = 0 ;
31163 PyObject * obj1 = 0 ;
31164 char * kwnames[] = {
31165 (char *) "self",(char *) "size", NULL
31166 };
31167
31168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31170 if (!SWIG_IsOK(res1)) {
31171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31172 }
31173 arg1 = reinterpret_cast< wxWindow * >(argp1);
31174 if (obj1) {
31175 {
31176 arg2 = &temp2;
31177 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31178 }
31179 }
31180 {
31181 PyThreadState* __tstate = wxPyBeginAllowThreads();
31182 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31183 wxPyEndAllowThreads(__tstate);
31184 if (PyErr_Occurred()) SWIG_fail;
31185 }
31186 resultobj = SWIG_Py_Void();
31187 return resultobj;
31188 fail:
31189 return NULL;
31190 }
31191
31192
31193 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31194 PyObject *resultobj = 0;
31195 wxWindow *arg1 = (wxWindow *) 0 ;
31196 void *argp1 = 0 ;
31197 int res1 = 0 ;
31198 PyObject *swig_obj[1] ;
31199
31200 if (!args) SWIG_fail;
31201 swig_obj[0] = args;
31202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31203 if (!SWIG_IsOK(res1)) {
31204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31205 }
31206 arg1 = reinterpret_cast< wxWindow * >(argp1);
31207 {
31208 PyThreadState* __tstate = wxPyBeginAllowThreads();
31209 (arg1)->Raise();
31210 wxPyEndAllowThreads(__tstate);
31211 if (PyErr_Occurred()) SWIG_fail;
31212 }
31213 resultobj = SWIG_Py_Void();
31214 return resultobj;
31215 fail:
31216 return NULL;
31217 }
31218
31219
31220 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31221 PyObject *resultobj = 0;
31222 wxWindow *arg1 = (wxWindow *) 0 ;
31223 void *argp1 = 0 ;
31224 int res1 = 0 ;
31225 PyObject *swig_obj[1] ;
31226
31227 if (!args) SWIG_fail;
31228 swig_obj[0] = args;
31229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31230 if (!SWIG_IsOK(res1)) {
31231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31232 }
31233 arg1 = reinterpret_cast< wxWindow * >(argp1);
31234 {
31235 PyThreadState* __tstate = wxPyBeginAllowThreads();
31236 (arg1)->Lower();
31237 wxPyEndAllowThreads(__tstate);
31238 if (PyErr_Occurred()) SWIG_fail;
31239 }
31240 resultobj = SWIG_Py_Void();
31241 return resultobj;
31242 fail:
31243 return NULL;
31244 }
31245
31246
31247 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31248 PyObject *resultobj = 0;
31249 wxWindow *arg1 = (wxWindow *) 0 ;
31250 wxSize *arg2 = 0 ;
31251 void *argp1 = 0 ;
31252 int res1 = 0 ;
31253 wxSize temp2 ;
31254 PyObject * obj0 = 0 ;
31255 PyObject * obj1 = 0 ;
31256 char * kwnames[] = {
31257 (char *) "self",(char *) "size", NULL
31258 };
31259
31260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31262 if (!SWIG_IsOK(res1)) {
31263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31264 }
31265 arg1 = reinterpret_cast< wxWindow * >(argp1);
31266 {
31267 arg2 = &temp2;
31268 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31269 }
31270 {
31271 PyThreadState* __tstate = wxPyBeginAllowThreads();
31272 (arg1)->SetClientSize((wxSize const &)*arg2);
31273 wxPyEndAllowThreads(__tstate);
31274 if (PyErr_Occurred()) SWIG_fail;
31275 }
31276 resultobj = SWIG_Py_Void();
31277 return resultobj;
31278 fail:
31279 return NULL;
31280 }
31281
31282
31283 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31284 PyObject *resultobj = 0;
31285 wxWindow *arg1 = (wxWindow *) 0 ;
31286 int arg2 ;
31287 int arg3 ;
31288 void *argp1 = 0 ;
31289 int res1 = 0 ;
31290 int val2 ;
31291 int ecode2 = 0 ;
31292 int val3 ;
31293 int ecode3 = 0 ;
31294 PyObject * obj0 = 0 ;
31295 PyObject * obj1 = 0 ;
31296 PyObject * obj2 = 0 ;
31297 char * kwnames[] = {
31298 (char *) "self",(char *) "width",(char *) "height", NULL
31299 };
31300
31301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31303 if (!SWIG_IsOK(res1)) {
31304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31305 }
31306 arg1 = reinterpret_cast< wxWindow * >(argp1);
31307 ecode2 = SWIG_AsVal_int(obj1, &val2);
31308 if (!SWIG_IsOK(ecode2)) {
31309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31310 }
31311 arg2 = static_cast< int >(val2);
31312 ecode3 = SWIG_AsVal_int(obj2, &val3);
31313 if (!SWIG_IsOK(ecode3)) {
31314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31315 }
31316 arg3 = static_cast< int >(val3);
31317 {
31318 PyThreadState* __tstate = wxPyBeginAllowThreads();
31319 (arg1)->SetClientSize(arg2,arg3);
31320 wxPyEndAllowThreads(__tstate);
31321 if (PyErr_Occurred()) SWIG_fail;
31322 }
31323 resultobj = SWIG_Py_Void();
31324 return resultobj;
31325 fail:
31326 return NULL;
31327 }
31328
31329
31330 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31331 PyObject *resultobj = 0;
31332 wxWindow *arg1 = (wxWindow *) 0 ;
31333 wxRect *arg2 = 0 ;
31334 void *argp1 = 0 ;
31335 int res1 = 0 ;
31336 wxRect temp2 ;
31337 PyObject * obj0 = 0 ;
31338 PyObject * obj1 = 0 ;
31339 char * kwnames[] = {
31340 (char *) "self",(char *) "rect", NULL
31341 };
31342
31343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31345 if (!SWIG_IsOK(res1)) {
31346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31347 }
31348 arg1 = reinterpret_cast< wxWindow * >(argp1);
31349 {
31350 arg2 = &temp2;
31351 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31352 }
31353 {
31354 PyThreadState* __tstate = wxPyBeginAllowThreads();
31355 (arg1)->SetClientSize((wxRect const &)*arg2);
31356 wxPyEndAllowThreads(__tstate);
31357 if (PyErr_Occurred()) SWIG_fail;
31358 }
31359 resultobj = SWIG_Py_Void();
31360 return resultobj;
31361 fail:
31362 return NULL;
31363 }
31364
31365
31366 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31367 PyObject *resultobj = 0;
31368 wxWindow *arg1 = (wxWindow *) 0 ;
31369 wxPoint result;
31370 void *argp1 = 0 ;
31371 int res1 = 0 ;
31372 PyObject *swig_obj[1] ;
31373
31374 if (!args) SWIG_fail;
31375 swig_obj[0] = args;
31376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31377 if (!SWIG_IsOK(res1)) {
31378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31379 }
31380 arg1 = reinterpret_cast< wxWindow * >(argp1);
31381 {
31382 PyThreadState* __tstate = wxPyBeginAllowThreads();
31383 result = ((wxWindow const *)arg1)->GetPosition();
31384 wxPyEndAllowThreads(__tstate);
31385 if (PyErr_Occurred()) SWIG_fail;
31386 }
31387 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31388 return resultobj;
31389 fail:
31390 return NULL;
31391 }
31392
31393
31394 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31395 PyObject *resultobj = 0;
31396 wxWindow *arg1 = (wxWindow *) 0 ;
31397 int *arg2 = (int *) 0 ;
31398 int *arg3 = (int *) 0 ;
31399 void *argp1 = 0 ;
31400 int res1 = 0 ;
31401 int temp2 ;
31402 int res2 = SWIG_TMPOBJ ;
31403 int temp3 ;
31404 int res3 = SWIG_TMPOBJ ;
31405 PyObject *swig_obj[1] ;
31406
31407 arg2 = &temp2;
31408 arg3 = &temp3;
31409 if (!args) SWIG_fail;
31410 swig_obj[0] = args;
31411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31412 if (!SWIG_IsOK(res1)) {
31413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31414 }
31415 arg1 = reinterpret_cast< wxWindow * >(argp1);
31416 {
31417 PyThreadState* __tstate = wxPyBeginAllowThreads();
31418 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31419 wxPyEndAllowThreads(__tstate);
31420 if (PyErr_Occurred()) SWIG_fail;
31421 }
31422 resultobj = SWIG_Py_Void();
31423 if (SWIG_IsTmpObj(res2)) {
31424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31425 } else {
31426 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31427 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31428 }
31429 if (SWIG_IsTmpObj(res3)) {
31430 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31431 } else {
31432 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31433 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31434 }
31435 return resultobj;
31436 fail:
31437 return NULL;
31438 }
31439
31440
31441 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31442 PyObject *resultobj = 0;
31443 wxWindow *arg1 = (wxWindow *) 0 ;
31444 wxPoint result;
31445 void *argp1 = 0 ;
31446 int res1 = 0 ;
31447 PyObject *swig_obj[1] ;
31448
31449 if (!args) SWIG_fail;
31450 swig_obj[0] = args;
31451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31452 if (!SWIG_IsOK(res1)) {
31453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31454 }
31455 arg1 = reinterpret_cast< wxWindow * >(argp1);
31456 {
31457 PyThreadState* __tstate = wxPyBeginAllowThreads();
31458 result = ((wxWindow const *)arg1)->GetScreenPosition();
31459 wxPyEndAllowThreads(__tstate);
31460 if (PyErr_Occurred()) SWIG_fail;
31461 }
31462 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31463 return resultobj;
31464 fail:
31465 return NULL;
31466 }
31467
31468
31469 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31470 PyObject *resultobj = 0;
31471 wxWindow *arg1 = (wxWindow *) 0 ;
31472 int *arg2 = (int *) 0 ;
31473 int *arg3 = (int *) 0 ;
31474 void *argp1 = 0 ;
31475 int res1 = 0 ;
31476 int temp2 ;
31477 int res2 = SWIG_TMPOBJ ;
31478 int temp3 ;
31479 int res3 = SWIG_TMPOBJ ;
31480 PyObject *swig_obj[1] ;
31481
31482 arg2 = &temp2;
31483 arg3 = &temp3;
31484 if (!args) SWIG_fail;
31485 swig_obj[0] = args;
31486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31487 if (!SWIG_IsOK(res1)) {
31488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31489 }
31490 arg1 = reinterpret_cast< wxWindow * >(argp1);
31491 {
31492 PyThreadState* __tstate = wxPyBeginAllowThreads();
31493 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31494 wxPyEndAllowThreads(__tstate);
31495 if (PyErr_Occurred()) SWIG_fail;
31496 }
31497 resultobj = SWIG_Py_Void();
31498 if (SWIG_IsTmpObj(res2)) {
31499 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31500 } else {
31501 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31502 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31503 }
31504 if (SWIG_IsTmpObj(res3)) {
31505 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31506 } else {
31507 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31508 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31509 }
31510 return resultobj;
31511 fail:
31512 return NULL;
31513 }
31514
31515
31516 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31517 PyObject *resultobj = 0;
31518 wxWindow *arg1 = (wxWindow *) 0 ;
31519 wxRect result;
31520 void *argp1 = 0 ;
31521 int res1 = 0 ;
31522 PyObject *swig_obj[1] ;
31523
31524 if (!args) SWIG_fail;
31525 swig_obj[0] = args;
31526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31527 if (!SWIG_IsOK(res1)) {
31528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31529 }
31530 arg1 = reinterpret_cast< wxWindow * >(argp1);
31531 {
31532 PyThreadState* __tstate = wxPyBeginAllowThreads();
31533 result = ((wxWindow const *)arg1)->GetScreenRect();
31534 wxPyEndAllowThreads(__tstate);
31535 if (PyErr_Occurred()) SWIG_fail;
31536 }
31537 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31538 return resultobj;
31539 fail:
31540 return NULL;
31541 }
31542
31543
31544 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31545 PyObject *resultobj = 0;
31546 wxWindow *arg1 = (wxWindow *) 0 ;
31547 wxSize result;
31548 void *argp1 = 0 ;
31549 int res1 = 0 ;
31550 PyObject *swig_obj[1] ;
31551
31552 if (!args) SWIG_fail;
31553 swig_obj[0] = args;
31554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31555 if (!SWIG_IsOK(res1)) {
31556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31557 }
31558 arg1 = reinterpret_cast< wxWindow * >(argp1);
31559 {
31560 PyThreadState* __tstate = wxPyBeginAllowThreads();
31561 result = ((wxWindow const *)arg1)->GetSize();
31562 wxPyEndAllowThreads(__tstate);
31563 if (PyErr_Occurred()) SWIG_fail;
31564 }
31565 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31566 return resultobj;
31567 fail:
31568 return NULL;
31569 }
31570
31571
31572 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31573 PyObject *resultobj = 0;
31574 wxWindow *arg1 = (wxWindow *) 0 ;
31575 int *arg2 = (int *) 0 ;
31576 int *arg3 = (int *) 0 ;
31577 void *argp1 = 0 ;
31578 int res1 = 0 ;
31579 int temp2 ;
31580 int res2 = SWIG_TMPOBJ ;
31581 int temp3 ;
31582 int res3 = SWIG_TMPOBJ ;
31583 PyObject *swig_obj[1] ;
31584
31585 arg2 = &temp2;
31586 arg3 = &temp3;
31587 if (!args) SWIG_fail;
31588 swig_obj[0] = args;
31589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31590 if (!SWIG_IsOK(res1)) {
31591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31592 }
31593 arg1 = reinterpret_cast< wxWindow * >(argp1);
31594 {
31595 PyThreadState* __tstate = wxPyBeginAllowThreads();
31596 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31597 wxPyEndAllowThreads(__tstate);
31598 if (PyErr_Occurred()) SWIG_fail;
31599 }
31600 resultobj = SWIG_Py_Void();
31601 if (SWIG_IsTmpObj(res2)) {
31602 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31603 } else {
31604 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31605 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31606 }
31607 if (SWIG_IsTmpObj(res3)) {
31608 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31609 } else {
31610 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31612 }
31613 return resultobj;
31614 fail:
31615 return NULL;
31616 }
31617
31618
31619 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31620 PyObject *resultobj = 0;
31621 wxWindow *arg1 = (wxWindow *) 0 ;
31622 wxRect result;
31623 void *argp1 = 0 ;
31624 int res1 = 0 ;
31625 PyObject *swig_obj[1] ;
31626
31627 if (!args) SWIG_fail;
31628 swig_obj[0] = args;
31629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31630 if (!SWIG_IsOK(res1)) {
31631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31632 }
31633 arg1 = reinterpret_cast< wxWindow * >(argp1);
31634 {
31635 PyThreadState* __tstate = wxPyBeginAllowThreads();
31636 result = ((wxWindow const *)arg1)->GetRect();
31637 wxPyEndAllowThreads(__tstate);
31638 if (PyErr_Occurred()) SWIG_fail;
31639 }
31640 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31641 return resultobj;
31642 fail:
31643 return NULL;
31644 }
31645
31646
31647 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31648 PyObject *resultobj = 0;
31649 wxWindow *arg1 = (wxWindow *) 0 ;
31650 wxSize result;
31651 void *argp1 = 0 ;
31652 int res1 = 0 ;
31653 PyObject *swig_obj[1] ;
31654
31655 if (!args) SWIG_fail;
31656 swig_obj[0] = args;
31657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31658 if (!SWIG_IsOK(res1)) {
31659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31660 }
31661 arg1 = reinterpret_cast< wxWindow * >(argp1);
31662 {
31663 PyThreadState* __tstate = wxPyBeginAllowThreads();
31664 result = ((wxWindow const *)arg1)->GetClientSize();
31665 wxPyEndAllowThreads(__tstate);
31666 if (PyErr_Occurred()) SWIG_fail;
31667 }
31668 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31669 return resultobj;
31670 fail:
31671 return NULL;
31672 }
31673
31674
31675 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31676 PyObject *resultobj = 0;
31677 wxWindow *arg1 = (wxWindow *) 0 ;
31678 int *arg2 = (int *) 0 ;
31679 int *arg3 = (int *) 0 ;
31680 void *argp1 = 0 ;
31681 int res1 = 0 ;
31682 int temp2 ;
31683 int res2 = SWIG_TMPOBJ ;
31684 int temp3 ;
31685 int res3 = SWIG_TMPOBJ ;
31686 PyObject *swig_obj[1] ;
31687
31688 arg2 = &temp2;
31689 arg3 = &temp3;
31690 if (!args) SWIG_fail;
31691 swig_obj[0] = args;
31692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31693 if (!SWIG_IsOK(res1)) {
31694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31695 }
31696 arg1 = reinterpret_cast< wxWindow * >(argp1);
31697 {
31698 PyThreadState* __tstate = wxPyBeginAllowThreads();
31699 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31700 wxPyEndAllowThreads(__tstate);
31701 if (PyErr_Occurred()) SWIG_fail;
31702 }
31703 resultobj = SWIG_Py_Void();
31704 if (SWIG_IsTmpObj(res2)) {
31705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31706 } else {
31707 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31708 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31709 }
31710 if (SWIG_IsTmpObj(res3)) {
31711 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31712 } else {
31713 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31714 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31715 }
31716 return resultobj;
31717 fail:
31718 return NULL;
31719 }
31720
31721
31722 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31723 PyObject *resultobj = 0;
31724 wxWindow *arg1 = (wxWindow *) 0 ;
31725 wxPoint result;
31726 void *argp1 = 0 ;
31727 int res1 = 0 ;
31728 PyObject *swig_obj[1] ;
31729
31730 if (!args) SWIG_fail;
31731 swig_obj[0] = args;
31732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31733 if (!SWIG_IsOK(res1)) {
31734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31735 }
31736 arg1 = reinterpret_cast< wxWindow * >(argp1);
31737 {
31738 PyThreadState* __tstate = wxPyBeginAllowThreads();
31739 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31740 wxPyEndAllowThreads(__tstate);
31741 if (PyErr_Occurred()) SWIG_fail;
31742 }
31743 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31744 return resultobj;
31745 fail:
31746 return NULL;
31747 }
31748
31749
31750 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31751 PyObject *resultobj = 0;
31752 wxWindow *arg1 = (wxWindow *) 0 ;
31753 wxRect result;
31754 void *argp1 = 0 ;
31755 int res1 = 0 ;
31756 PyObject *swig_obj[1] ;
31757
31758 if (!args) SWIG_fail;
31759 swig_obj[0] = args;
31760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31761 if (!SWIG_IsOK(res1)) {
31762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31763 }
31764 arg1 = reinterpret_cast< wxWindow * >(argp1);
31765 {
31766 PyThreadState* __tstate = wxPyBeginAllowThreads();
31767 result = ((wxWindow const *)arg1)->GetClientRect();
31768 wxPyEndAllowThreads(__tstate);
31769 if (PyErr_Occurred()) SWIG_fail;
31770 }
31771 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31772 return resultobj;
31773 fail:
31774 return NULL;
31775 }
31776
31777
31778 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31779 PyObject *resultobj = 0;
31780 wxWindow *arg1 = (wxWindow *) 0 ;
31781 wxSize result;
31782 void *argp1 = 0 ;
31783 int res1 = 0 ;
31784 PyObject *swig_obj[1] ;
31785
31786 if (!args) SWIG_fail;
31787 swig_obj[0] = args;
31788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31789 if (!SWIG_IsOK(res1)) {
31790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31791 }
31792 arg1 = reinterpret_cast< wxWindow * >(argp1);
31793 {
31794 PyThreadState* __tstate = wxPyBeginAllowThreads();
31795 result = ((wxWindow const *)arg1)->GetBestSize();
31796 wxPyEndAllowThreads(__tstate);
31797 if (PyErr_Occurred()) SWIG_fail;
31798 }
31799 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31800 return resultobj;
31801 fail:
31802 return NULL;
31803 }
31804
31805
31806 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31807 PyObject *resultobj = 0;
31808 wxWindow *arg1 = (wxWindow *) 0 ;
31809 int *arg2 = (int *) 0 ;
31810 int *arg3 = (int *) 0 ;
31811 void *argp1 = 0 ;
31812 int res1 = 0 ;
31813 int temp2 ;
31814 int res2 = SWIG_TMPOBJ ;
31815 int temp3 ;
31816 int res3 = SWIG_TMPOBJ ;
31817 PyObject *swig_obj[1] ;
31818
31819 arg2 = &temp2;
31820 arg3 = &temp3;
31821 if (!args) SWIG_fail;
31822 swig_obj[0] = args;
31823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31824 if (!SWIG_IsOK(res1)) {
31825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31826 }
31827 arg1 = reinterpret_cast< wxWindow * >(argp1);
31828 {
31829 PyThreadState* __tstate = wxPyBeginAllowThreads();
31830 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31831 wxPyEndAllowThreads(__tstate);
31832 if (PyErr_Occurred()) SWIG_fail;
31833 }
31834 resultobj = SWIG_Py_Void();
31835 if (SWIG_IsTmpObj(res2)) {
31836 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31837 } else {
31838 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31840 }
31841 if (SWIG_IsTmpObj(res3)) {
31842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31843 } else {
31844 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31846 }
31847 return resultobj;
31848 fail:
31849 return NULL;
31850 }
31851
31852
31853 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31854 PyObject *resultobj = 0;
31855 wxWindow *arg1 = (wxWindow *) 0 ;
31856 void *argp1 = 0 ;
31857 int res1 = 0 ;
31858 PyObject *swig_obj[1] ;
31859
31860 if (!args) SWIG_fail;
31861 swig_obj[0] = args;
31862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31863 if (!SWIG_IsOK(res1)) {
31864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31865 }
31866 arg1 = reinterpret_cast< wxWindow * >(argp1);
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 (arg1)->InvalidateBestSize();
31870 wxPyEndAllowThreads(__tstate);
31871 if (PyErr_Occurred()) SWIG_fail;
31872 }
31873 resultobj = SWIG_Py_Void();
31874 return resultobj;
31875 fail:
31876 return NULL;
31877 }
31878
31879
31880 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31881 PyObject *resultobj = 0;
31882 wxWindow *arg1 = (wxWindow *) 0 ;
31883 wxSize *arg2 = 0 ;
31884 void *argp1 = 0 ;
31885 int res1 = 0 ;
31886 wxSize temp2 ;
31887 PyObject * obj0 = 0 ;
31888 PyObject * obj1 = 0 ;
31889 char * kwnames[] = {
31890 (char *) "self",(char *) "size", NULL
31891 };
31892
31893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31895 if (!SWIG_IsOK(res1)) {
31896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31897 }
31898 arg1 = reinterpret_cast< wxWindow * >(argp1);
31899 {
31900 arg2 = &temp2;
31901 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31902 }
31903 {
31904 PyThreadState* __tstate = wxPyBeginAllowThreads();
31905 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31906 wxPyEndAllowThreads(__tstate);
31907 if (PyErr_Occurred()) SWIG_fail;
31908 }
31909 resultobj = SWIG_Py_Void();
31910 return resultobj;
31911 fail:
31912 return NULL;
31913 }
31914
31915
31916 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31917 PyObject *resultobj = 0;
31918 wxWindow *arg1 = (wxWindow *) 0 ;
31919 wxSize result;
31920 void *argp1 = 0 ;
31921 int res1 = 0 ;
31922 PyObject *swig_obj[1] ;
31923
31924 if (!args) SWIG_fail;
31925 swig_obj[0] = args;
31926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31927 if (!SWIG_IsOK(res1)) {
31928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31929 }
31930 arg1 = reinterpret_cast< wxWindow * >(argp1);
31931 {
31932 PyThreadState* __tstate = wxPyBeginAllowThreads();
31933 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31934 wxPyEndAllowThreads(__tstate);
31935 if (PyErr_Occurred()) SWIG_fail;
31936 }
31937 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31938 return resultobj;
31939 fail:
31940 return NULL;
31941 }
31942
31943
31944 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31945 PyObject *resultobj = 0;
31946 wxWindow *arg1 = (wxWindow *) 0 ;
31947 wxSize result;
31948 void *argp1 = 0 ;
31949 int res1 = 0 ;
31950 PyObject *swig_obj[1] ;
31951
31952 if (!args) SWIG_fail;
31953 swig_obj[0] = args;
31954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31955 if (!SWIG_IsOK(res1)) {
31956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31957 }
31958 arg1 = reinterpret_cast< wxWindow * >(argp1);
31959 {
31960 PyThreadState* __tstate = wxPyBeginAllowThreads();
31961 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31962 wxPyEndAllowThreads(__tstate);
31963 if (PyErr_Occurred()) SWIG_fail;
31964 }
31965 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31966 return resultobj;
31967 fail:
31968 return NULL;
31969 }
31970
31971
31972 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31973 PyObject *resultobj = 0;
31974 wxWindow *arg1 = (wxWindow *) 0 ;
31975 int arg2 = (int) wxBOTH ;
31976 void *argp1 = 0 ;
31977 int res1 = 0 ;
31978 int val2 ;
31979 int ecode2 = 0 ;
31980 PyObject * obj0 = 0 ;
31981 PyObject * obj1 = 0 ;
31982 char * kwnames[] = {
31983 (char *) "self",(char *) "direction", NULL
31984 };
31985
31986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31988 if (!SWIG_IsOK(res1)) {
31989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31990 }
31991 arg1 = reinterpret_cast< wxWindow * >(argp1);
31992 if (obj1) {
31993 ecode2 = SWIG_AsVal_int(obj1, &val2);
31994 if (!SWIG_IsOK(ecode2)) {
31995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31996 }
31997 arg2 = static_cast< int >(val2);
31998 }
31999 {
32000 PyThreadState* __tstate = wxPyBeginAllowThreads();
32001 (arg1)->Center(arg2);
32002 wxPyEndAllowThreads(__tstate);
32003 if (PyErr_Occurred()) SWIG_fail;
32004 }
32005 resultobj = SWIG_Py_Void();
32006 return resultobj;
32007 fail:
32008 return NULL;
32009 }
32010
32011
32012 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32013 PyObject *resultobj = 0;
32014 wxWindow *arg1 = (wxWindow *) 0 ;
32015 int arg2 = (int) wxBOTH ;
32016 void *argp1 = 0 ;
32017 int res1 = 0 ;
32018 int val2 ;
32019 int ecode2 = 0 ;
32020 PyObject * obj0 = 0 ;
32021 PyObject * obj1 = 0 ;
32022 char * kwnames[] = {
32023 (char *) "self",(char *) "dir", NULL
32024 };
32025
32026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32028 if (!SWIG_IsOK(res1)) {
32029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32030 }
32031 arg1 = reinterpret_cast< wxWindow * >(argp1);
32032 if (obj1) {
32033 ecode2 = SWIG_AsVal_int(obj1, &val2);
32034 if (!SWIG_IsOK(ecode2)) {
32035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32036 }
32037 arg2 = static_cast< int >(val2);
32038 }
32039 {
32040 PyThreadState* __tstate = wxPyBeginAllowThreads();
32041 (arg1)->CenterOnParent(arg2);
32042 wxPyEndAllowThreads(__tstate);
32043 if (PyErr_Occurred()) SWIG_fail;
32044 }
32045 resultobj = SWIG_Py_Void();
32046 return resultobj;
32047 fail:
32048 return NULL;
32049 }
32050
32051
32052 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32053 PyObject *resultobj = 0;
32054 wxWindow *arg1 = (wxWindow *) 0 ;
32055 void *argp1 = 0 ;
32056 int res1 = 0 ;
32057 PyObject *swig_obj[1] ;
32058
32059 if (!args) SWIG_fail;
32060 swig_obj[0] = args;
32061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32062 if (!SWIG_IsOK(res1)) {
32063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32064 }
32065 arg1 = reinterpret_cast< wxWindow * >(argp1);
32066 {
32067 PyThreadState* __tstate = wxPyBeginAllowThreads();
32068 (arg1)->Fit();
32069 wxPyEndAllowThreads(__tstate);
32070 if (PyErr_Occurred()) SWIG_fail;
32071 }
32072 resultobj = SWIG_Py_Void();
32073 return resultobj;
32074 fail:
32075 return NULL;
32076 }
32077
32078
32079 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32080 PyObject *resultobj = 0;
32081 wxWindow *arg1 = (wxWindow *) 0 ;
32082 void *argp1 = 0 ;
32083 int res1 = 0 ;
32084 PyObject *swig_obj[1] ;
32085
32086 if (!args) SWIG_fail;
32087 swig_obj[0] = args;
32088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32089 if (!SWIG_IsOK(res1)) {
32090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32091 }
32092 arg1 = reinterpret_cast< wxWindow * >(argp1);
32093 {
32094 PyThreadState* __tstate = wxPyBeginAllowThreads();
32095 (arg1)->FitInside();
32096 wxPyEndAllowThreads(__tstate);
32097 if (PyErr_Occurred()) SWIG_fail;
32098 }
32099 resultobj = SWIG_Py_Void();
32100 return resultobj;
32101 fail:
32102 return NULL;
32103 }
32104
32105
32106 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32107 PyObject *resultobj = 0;
32108 wxWindow *arg1 = (wxWindow *) 0 ;
32109 int arg2 ;
32110 int arg3 ;
32111 int arg4 = (int) -1 ;
32112 int arg5 = (int) -1 ;
32113 int arg6 = (int) -1 ;
32114 int arg7 = (int) -1 ;
32115 void *argp1 = 0 ;
32116 int res1 = 0 ;
32117 int val2 ;
32118 int ecode2 = 0 ;
32119 int val3 ;
32120 int ecode3 = 0 ;
32121 int val4 ;
32122 int ecode4 = 0 ;
32123 int val5 ;
32124 int ecode5 = 0 ;
32125 int val6 ;
32126 int ecode6 = 0 ;
32127 int val7 ;
32128 int ecode7 = 0 ;
32129 PyObject * obj0 = 0 ;
32130 PyObject * obj1 = 0 ;
32131 PyObject * obj2 = 0 ;
32132 PyObject * obj3 = 0 ;
32133 PyObject * obj4 = 0 ;
32134 PyObject * obj5 = 0 ;
32135 PyObject * obj6 = 0 ;
32136 char * kwnames[] = {
32137 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32138 };
32139
32140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32142 if (!SWIG_IsOK(res1)) {
32143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32144 }
32145 arg1 = reinterpret_cast< wxWindow * >(argp1);
32146 ecode2 = SWIG_AsVal_int(obj1, &val2);
32147 if (!SWIG_IsOK(ecode2)) {
32148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32149 }
32150 arg2 = static_cast< int >(val2);
32151 ecode3 = SWIG_AsVal_int(obj2, &val3);
32152 if (!SWIG_IsOK(ecode3)) {
32153 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32154 }
32155 arg3 = static_cast< int >(val3);
32156 if (obj3) {
32157 ecode4 = SWIG_AsVal_int(obj3, &val4);
32158 if (!SWIG_IsOK(ecode4)) {
32159 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32160 }
32161 arg4 = static_cast< int >(val4);
32162 }
32163 if (obj4) {
32164 ecode5 = SWIG_AsVal_int(obj4, &val5);
32165 if (!SWIG_IsOK(ecode5)) {
32166 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32167 }
32168 arg5 = static_cast< int >(val5);
32169 }
32170 if (obj5) {
32171 ecode6 = SWIG_AsVal_int(obj5, &val6);
32172 if (!SWIG_IsOK(ecode6)) {
32173 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32174 }
32175 arg6 = static_cast< int >(val6);
32176 }
32177 if (obj6) {
32178 ecode7 = SWIG_AsVal_int(obj6, &val7);
32179 if (!SWIG_IsOK(ecode7)) {
32180 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32181 }
32182 arg7 = static_cast< int >(val7);
32183 }
32184 {
32185 PyThreadState* __tstate = wxPyBeginAllowThreads();
32186 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32187 wxPyEndAllowThreads(__tstate);
32188 if (PyErr_Occurred()) SWIG_fail;
32189 }
32190 resultobj = SWIG_Py_Void();
32191 return resultobj;
32192 fail:
32193 return NULL;
32194 }
32195
32196
32197 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32198 PyObject *resultobj = 0;
32199 wxWindow *arg1 = (wxWindow *) 0 ;
32200 wxSize *arg2 = 0 ;
32201 wxSize const &arg3_defvalue = wxDefaultSize ;
32202 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32203 wxSize const &arg4_defvalue = wxDefaultSize ;
32204 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32205 void *argp1 = 0 ;
32206 int res1 = 0 ;
32207 wxSize temp2 ;
32208 wxSize temp3 ;
32209 wxSize temp4 ;
32210 PyObject * obj0 = 0 ;
32211 PyObject * obj1 = 0 ;
32212 PyObject * obj2 = 0 ;
32213 PyObject * obj3 = 0 ;
32214 char * kwnames[] = {
32215 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32216 };
32217
32218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32220 if (!SWIG_IsOK(res1)) {
32221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32222 }
32223 arg1 = reinterpret_cast< wxWindow * >(argp1);
32224 {
32225 arg2 = &temp2;
32226 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32227 }
32228 if (obj2) {
32229 {
32230 arg3 = &temp3;
32231 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32232 }
32233 }
32234 if (obj3) {
32235 {
32236 arg4 = &temp4;
32237 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32238 }
32239 }
32240 {
32241 PyThreadState* __tstate = wxPyBeginAllowThreads();
32242 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32243 wxPyEndAllowThreads(__tstate);
32244 if (PyErr_Occurred()) SWIG_fail;
32245 }
32246 resultobj = SWIG_Py_Void();
32247 return resultobj;
32248 fail:
32249 return NULL;
32250 }
32251
32252
32253 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32254 PyObject *resultobj = 0;
32255 wxWindow *arg1 = (wxWindow *) 0 ;
32256 int arg2 ;
32257 int arg3 ;
32258 int arg4 = (int) -1 ;
32259 int arg5 = (int) -1 ;
32260 void *argp1 = 0 ;
32261 int res1 = 0 ;
32262 int val2 ;
32263 int ecode2 = 0 ;
32264 int val3 ;
32265 int ecode3 = 0 ;
32266 int val4 ;
32267 int ecode4 = 0 ;
32268 int val5 ;
32269 int ecode5 = 0 ;
32270 PyObject * obj0 = 0 ;
32271 PyObject * obj1 = 0 ;
32272 PyObject * obj2 = 0 ;
32273 PyObject * obj3 = 0 ;
32274 PyObject * obj4 = 0 ;
32275 char * kwnames[] = {
32276 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32277 };
32278
32279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32281 if (!SWIG_IsOK(res1)) {
32282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32283 }
32284 arg1 = reinterpret_cast< wxWindow * >(argp1);
32285 ecode2 = SWIG_AsVal_int(obj1, &val2);
32286 if (!SWIG_IsOK(ecode2)) {
32287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32288 }
32289 arg2 = static_cast< int >(val2);
32290 ecode3 = SWIG_AsVal_int(obj2, &val3);
32291 if (!SWIG_IsOK(ecode3)) {
32292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32293 }
32294 arg3 = static_cast< int >(val3);
32295 if (obj3) {
32296 ecode4 = SWIG_AsVal_int(obj3, &val4);
32297 if (!SWIG_IsOK(ecode4)) {
32298 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32299 }
32300 arg4 = static_cast< int >(val4);
32301 }
32302 if (obj4) {
32303 ecode5 = SWIG_AsVal_int(obj4, &val5);
32304 if (!SWIG_IsOK(ecode5)) {
32305 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32306 }
32307 arg5 = static_cast< int >(val5);
32308 }
32309 {
32310 PyThreadState* __tstate = wxPyBeginAllowThreads();
32311 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32312 wxPyEndAllowThreads(__tstate);
32313 if (PyErr_Occurred()) SWIG_fail;
32314 }
32315 resultobj = SWIG_Py_Void();
32316 return resultobj;
32317 fail:
32318 return NULL;
32319 }
32320
32321
32322 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32323 PyObject *resultobj = 0;
32324 wxWindow *arg1 = (wxWindow *) 0 ;
32325 wxSize *arg2 = 0 ;
32326 wxSize const &arg3_defvalue = wxDefaultSize ;
32327 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32328 void *argp1 = 0 ;
32329 int res1 = 0 ;
32330 wxSize temp2 ;
32331 wxSize temp3 ;
32332 PyObject * obj0 = 0 ;
32333 PyObject * obj1 = 0 ;
32334 PyObject * obj2 = 0 ;
32335 char * kwnames[] = {
32336 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32337 };
32338
32339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32341 if (!SWIG_IsOK(res1)) {
32342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32343 }
32344 arg1 = reinterpret_cast< wxWindow * >(argp1);
32345 {
32346 arg2 = &temp2;
32347 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32348 }
32349 if (obj2) {
32350 {
32351 arg3 = &temp3;
32352 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32353 }
32354 }
32355 {
32356 PyThreadState* __tstate = wxPyBeginAllowThreads();
32357 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32358 wxPyEndAllowThreads(__tstate);
32359 if (PyErr_Occurred()) SWIG_fail;
32360 }
32361 resultobj = SWIG_Py_Void();
32362 return resultobj;
32363 fail:
32364 return NULL;
32365 }
32366
32367
32368 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32369 PyObject *resultobj = 0;
32370 wxWindow *arg1 = (wxWindow *) 0 ;
32371 wxSize result;
32372 void *argp1 = 0 ;
32373 int res1 = 0 ;
32374 PyObject *swig_obj[1] ;
32375
32376 if (!args) SWIG_fail;
32377 swig_obj[0] = args;
32378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32379 if (!SWIG_IsOK(res1)) {
32380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32381 }
32382 arg1 = reinterpret_cast< wxWindow * >(argp1);
32383 {
32384 PyThreadState* __tstate = wxPyBeginAllowThreads();
32385 result = ((wxWindow const *)arg1)->GetMaxSize();
32386 wxPyEndAllowThreads(__tstate);
32387 if (PyErr_Occurred()) SWIG_fail;
32388 }
32389 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32390 return resultobj;
32391 fail:
32392 return NULL;
32393 }
32394
32395
32396 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32397 PyObject *resultobj = 0;
32398 wxWindow *arg1 = (wxWindow *) 0 ;
32399 wxSize result;
32400 void *argp1 = 0 ;
32401 int res1 = 0 ;
32402 PyObject *swig_obj[1] ;
32403
32404 if (!args) SWIG_fail;
32405 swig_obj[0] = args;
32406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32407 if (!SWIG_IsOK(res1)) {
32408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32409 }
32410 arg1 = reinterpret_cast< wxWindow * >(argp1);
32411 {
32412 PyThreadState* __tstate = wxPyBeginAllowThreads();
32413 result = ((wxWindow const *)arg1)->GetMinSize();
32414 wxPyEndAllowThreads(__tstate);
32415 if (PyErr_Occurred()) SWIG_fail;
32416 }
32417 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32418 return resultobj;
32419 fail:
32420 return NULL;
32421 }
32422
32423
32424 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32425 PyObject *resultobj = 0;
32426 wxWindow *arg1 = (wxWindow *) 0 ;
32427 wxSize *arg2 = 0 ;
32428 void *argp1 = 0 ;
32429 int res1 = 0 ;
32430 wxSize temp2 ;
32431 PyObject * obj0 = 0 ;
32432 PyObject * obj1 = 0 ;
32433 char * kwnames[] = {
32434 (char *) "self",(char *) "minSize", NULL
32435 };
32436
32437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32439 if (!SWIG_IsOK(res1)) {
32440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32441 }
32442 arg1 = reinterpret_cast< wxWindow * >(argp1);
32443 {
32444 arg2 = &temp2;
32445 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32446 }
32447 {
32448 PyThreadState* __tstate = wxPyBeginAllowThreads();
32449 (arg1)->SetMinSize((wxSize const &)*arg2);
32450 wxPyEndAllowThreads(__tstate);
32451 if (PyErr_Occurred()) SWIG_fail;
32452 }
32453 resultobj = SWIG_Py_Void();
32454 return resultobj;
32455 fail:
32456 return NULL;
32457 }
32458
32459
32460 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32461 PyObject *resultobj = 0;
32462 wxWindow *arg1 = (wxWindow *) 0 ;
32463 wxSize *arg2 = 0 ;
32464 void *argp1 = 0 ;
32465 int res1 = 0 ;
32466 wxSize temp2 ;
32467 PyObject * obj0 = 0 ;
32468 PyObject * obj1 = 0 ;
32469 char * kwnames[] = {
32470 (char *) "self",(char *) "maxSize", NULL
32471 };
32472
32473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32475 if (!SWIG_IsOK(res1)) {
32476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32477 }
32478 arg1 = reinterpret_cast< wxWindow * >(argp1);
32479 {
32480 arg2 = &temp2;
32481 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32482 }
32483 {
32484 PyThreadState* __tstate = wxPyBeginAllowThreads();
32485 (arg1)->SetMaxSize((wxSize const &)*arg2);
32486 wxPyEndAllowThreads(__tstate);
32487 if (PyErr_Occurred()) SWIG_fail;
32488 }
32489 resultobj = SWIG_Py_Void();
32490 return resultobj;
32491 fail:
32492 return NULL;
32493 }
32494
32495
32496 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32497 PyObject *resultobj = 0;
32498 wxWindow *arg1 = (wxWindow *) 0 ;
32499 int result;
32500 void *argp1 = 0 ;
32501 int res1 = 0 ;
32502 PyObject *swig_obj[1] ;
32503
32504 if (!args) SWIG_fail;
32505 swig_obj[0] = args;
32506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32507 if (!SWIG_IsOK(res1)) {
32508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32509 }
32510 arg1 = reinterpret_cast< wxWindow * >(argp1);
32511 {
32512 PyThreadState* __tstate = wxPyBeginAllowThreads();
32513 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32514 wxPyEndAllowThreads(__tstate);
32515 if (PyErr_Occurred()) SWIG_fail;
32516 }
32517 resultobj = SWIG_From_int(static_cast< int >(result));
32518 return resultobj;
32519 fail:
32520 return NULL;
32521 }
32522
32523
32524 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32525 PyObject *resultobj = 0;
32526 wxWindow *arg1 = (wxWindow *) 0 ;
32527 int result;
32528 void *argp1 = 0 ;
32529 int res1 = 0 ;
32530 PyObject *swig_obj[1] ;
32531
32532 if (!args) SWIG_fail;
32533 swig_obj[0] = args;
32534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32535 if (!SWIG_IsOK(res1)) {
32536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32537 }
32538 arg1 = reinterpret_cast< wxWindow * >(argp1);
32539 {
32540 PyThreadState* __tstate = wxPyBeginAllowThreads();
32541 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32542 wxPyEndAllowThreads(__tstate);
32543 if (PyErr_Occurred()) SWIG_fail;
32544 }
32545 resultobj = SWIG_From_int(static_cast< int >(result));
32546 return resultobj;
32547 fail:
32548 return NULL;
32549 }
32550
32551
32552 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32553 PyObject *resultobj = 0;
32554 wxWindow *arg1 = (wxWindow *) 0 ;
32555 int result;
32556 void *argp1 = 0 ;
32557 int res1 = 0 ;
32558 PyObject *swig_obj[1] ;
32559
32560 if (!args) SWIG_fail;
32561 swig_obj[0] = args;
32562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32563 if (!SWIG_IsOK(res1)) {
32564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32565 }
32566 arg1 = reinterpret_cast< wxWindow * >(argp1);
32567 {
32568 PyThreadState* __tstate = wxPyBeginAllowThreads();
32569 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32570 wxPyEndAllowThreads(__tstate);
32571 if (PyErr_Occurred()) SWIG_fail;
32572 }
32573 resultobj = SWIG_From_int(static_cast< int >(result));
32574 return resultobj;
32575 fail:
32576 return NULL;
32577 }
32578
32579
32580 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32581 PyObject *resultobj = 0;
32582 wxWindow *arg1 = (wxWindow *) 0 ;
32583 int result;
32584 void *argp1 = 0 ;
32585 int res1 = 0 ;
32586 PyObject *swig_obj[1] ;
32587
32588 if (!args) SWIG_fail;
32589 swig_obj[0] = args;
32590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32591 if (!SWIG_IsOK(res1)) {
32592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32593 }
32594 arg1 = reinterpret_cast< wxWindow * >(argp1);
32595 {
32596 PyThreadState* __tstate = wxPyBeginAllowThreads();
32597 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32598 wxPyEndAllowThreads(__tstate);
32599 if (PyErr_Occurred()) SWIG_fail;
32600 }
32601 resultobj = SWIG_From_int(static_cast< int >(result));
32602 return resultobj;
32603 fail:
32604 return NULL;
32605 }
32606
32607
32608 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32609 PyObject *resultobj = 0;
32610 wxWindow *arg1 = (wxWindow *) 0 ;
32611 wxSize *arg2 = 0 ;
32612 void *argp1 = 0 ;
32613 int res1 = 0 ;
32614 wxSize temp2 ;
32615 PyObject * obj0 = 0 ;
32616 PyObject * obj1 = 0 ;
32617 char * kwnames[] = {
32618 (char *) "self",(char *) "size", NULL
32619 };
32620
32621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32623 if (!SWIG_IsOK(res1)) {
32624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32625 }
32626 arg1 = reinterpret_cast< wxWindow * >(argp1);
32627 {
32628 arg2 = &temp2;
32629 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32630 }
32631 {
32632 PyThreadState* __tstate = wxPyBeginAllowThreads();
32633 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32634 wxPyEndAllowThreads(__tstate);
32635 if (PyErr_Occurred()) SWIG_fail;
32636 }
32637 resultobj = SWIG_Py_Void();
32638 return resultobj;
32639 fail:
32640 return NULL;
32641 }
32642
32643
32644 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32645 PyObject *resultobj = 0;
32646 wxWindow *arg1 = (wxWindow *) 0 ;
32647 int arg2 ;
32648 int arg3 ;
32649 void *argp1 = 0 ;
32650 int res1 = 0 ;
32651 int val2 ;
32652 int ecode2 = 0 ;
32653 int val3 ;
32654 int ecode3 = 0 ;
32655 PyObject * obj0 = 0 ;
32656 PyObject * obj1 = 0 ;
32657 PyObject * obj2 = 0 ;
32658 char * kwnames[] = {
32659 (char *) "self",(char *) "w",(char *) "h", NULL
32660 };
32661
32662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32664 if (!SWIG_IsOK(res1)) {
32665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32666 }
32667 arg1 = reinterpret_cast< wxWindow * >(argp1);
32668 ecode2 = SWIG_AsVal_int(obj1, &val2);
32669 if (!SWIG_IsOK(ecode2)) {
32670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32671 }
32672 arg2 = static_cast< int >(val2);
32673 ecode3 = SWIG_AsVal_int(obj2, &val3);
32674 if (!SWIG_IsOK(ecode3)) {
32675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32676 }
32677 arg3 = static_cast< int >(val3);
32678 {
32679 PyThreadState* __tstate = wxPyBeginAllowThreads();
32680 (arg1)->SetVirtualSize(arg2,arg3);
32681 wxPyEndAllowThreads(__tstate);
32682 if (PyErr_Occurred()) SWIG_fail;
32683 }
32684 resultobj = SWIG_Py_Void();
32685 return resultobj;
32686 fail:
32687 return NULL;
32688 }
32689
32690
32691 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32692 PyObject *resultobj = 0;
32693 wxWindow *arg1 = (wxWindow *) 0 ;
32694 wxSize result;
32695 void *argp1 = 0 ;
32696 int res1 = 0 ;
32697 PyObject *swig_obj[1] ;
32698
32699 if (!args) SWIG_fail;
32700 swig_obj[0] = args;
32701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32702 if (!SWIG_IsOK(res1)) {
32703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32704 }
32705 arg1 = reinterpret_cast< wxWindow * >(argp1);
32706 {
32707 PyThreadState* __tstate = wxPyBeginAllowThreads();
32708 result = ((wxWindow const *)arg1)->GetVirtualSize();
32709 wxPyEndAllowThreads(__tstate);
32710 if (PyErr_Occurred()) SWIG_fail;
32711 }
32712 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32713 return resultobj;
32714 fail:
32715 return NULL;
32716 }
32717
32718
32719 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32720 PyObject *resultobj = 0;
32721 wxWindow *arg1 = (wxWindow *) 0 ;
32722 int *arg2 = (int *) 0 ;
32723 int *arg3 = (int *) 0 ;
32724 void *argp1 = 0 ;
32725 int res1 = 0 ;
32726 int temp2 ;
32727 int res2 = SWIG_TMPOBJ ;
32728 int temp3 ;
32729 int res3 = SWIG_TMPOBJ ;
32730 PyObject *swig_obj[1] ;
32731
32732 arg2 = &temp2;
32733 arg3 = &temp3;
32734 if (!args) SWIG_fail;
32735 swig_obj[0] = args;
32736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32737 if (!SWIG_IsOK(res1)) {
32738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32739 }
32740 arg1 = reinterpret_cast< wxWindow * >(argp1);
32741 {
32742 PyThreadState* __tstate = wxPyBeginAllowThreads();
32743 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32744 wxPyEndAllowThreads(__tstate);
32745 if (PyErr_Occurred()) SWIG_fail;
32746 }
32747 resultobj = SWIG_Py_Void();
32748 if (SWIG_IsTmpObj(res2)) {
32749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32750 } else {
32751 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32753 }
32754 if (SWIG_IsTmpObj(res3)) {
32755 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32756 } else {
32757 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32758 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32759 }
32760 return resultobj;
32761 fail:
32762 return NULL;
32763 }
32764
32765
32766 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32767 PyObject *resultobj = 0;
32768 wxWindow *arg1 = (wxWindow *) 0 ;
32769 wxSize result;
32770 void *argp1 = 0 ;
32771 int res1 = 0 ;
32772 PyObject *swig_obj[1] ;
32773
32774 if (!args) SWIG_fail;
32775 swig_obj[0] = args;
32776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32777 if (!SWIG_IsOK(res1)) {
32778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32779 }
32780 arg1 = reinterpret_cast< wxWindow * >(argp1);
32781 {
32782 PyThreadState* __tstate = wxPyBeginAllowThreads();
32783 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32784 wxPyEndAllowThreads(__tstate);
32785 if (PyErr_Occurred()) SWIG_fail;
32786 }
32787 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32788 return resultobj;
32789 fail:
32790 return NULL;
32791 }
32792
32793
32794 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32795 PyObject *resultobj = 0;
32796 wxWindow *arg1 = (wxWindow *) 0 ;
32797 bool arg2 = (bool) true ;
32798 bool result;
32799 void *argp1 = 0 ;
32800 int res1 = 0 ;
32801 bool val2 ;
32802 int ecode2 = 0 ;
32803 PyObject * obj0 = 0 ;
32804 PyObject * obj1 = 0 ;
32805 char * kwnames[] = {
32806 (char *) "self",(char *) "show", NULL
32807 };
32808
32809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32811 if (!SWIG_IsOK(res1)) {
32812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32813 }
32814 arg1 = reinterpret_cast< wxWindow * >(argp1);
32815 if (obj1) {
32816 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32817 if (!SWIG_IsOK(ecode2)) {
32818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32819 }
32820 arg2 = static_cast< bool >(val2);
32821 }
32822 {
32823 PyThreadState* __tstate = wxPyBeginAllowThreads();
32824 result = (bool)(arg1)->Show(arg2);
32825 wxPyEndAllowThreads(__tstate);
32826 if (PyErr_Occurred()) SWIG_fail;
32827 }
32828 {
32829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32830 }
32831 return resultobj;
32832 fail:
32833 return NULL;
32834 }
32835
32836
32837 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32838 PyObject *resultobj = 0;
32839 wxWindow *arg1 = (wxWindow *) 0 ;
32840 bool result;
32841 void *argp1 = 0 ;
32842 int res1 = 0 ;
32843 PyObject *swig_obj[1] ;
32844
32845 if (!args) SWIG_fail;
32846 swig_obj[0] = args;
32847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32848 if (!SWIG_IsOK(res1)) {
32849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32850 }
32851 arg1 = reinterpret_cast< wxWindow * >(argp1);
32852 {
32853 PyThreadState* __tstate = wxPyBeginAllowThreads();
32854 result = (bool)(arg1)->Hide();
32855 wxPyEndAllowThreads(__tstate);
32856 if (PyErr_Occurred()) SWIG_fail;
32857 }
32858 {
32859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32860 }
32861 return resultobj;
32862 fail:
32863 return NULL;
32864 }
32865
32866
32867 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32868 PyObject *resultobj = 0;
32869 wxWindow *arg1 = (wxWindow *) 0 ;
32870 bool arg2 = (bool) true ;
32871 bool result;
32872 void *argp1 = 0 ;
32873 int res1 = 0 ;
32874 bool val2 ;
32875 int ecode2 = 0 ;
32876 PyObject * obj0 = 0 ;
32877 PyObject * obj1 = 0 ;
32878 char * kwnames[] = {
32879 (char *) "self",(char *) "enable", NULL
32880 };
32881
32882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32884 if (!SWIG_IsOK(res1)) {
32885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32886 }
32887 arg1 = reinterpret_cast< wxWindow * >(argp1);
32888 if (obj1) {
32889 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32890 if (!SWIG_IsOK(ecode2)) {
32891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32892 }
32893 arg2 = static_cast< bool >(val2);
32894 }
32895 {
32896 PyThreadState* __tstate = wxPyBeginAllowThreads();
32897 result = (bool)(arg1)->Enable(arg2);
32898 wxPyEndAllowThreads(__tstate);
32899 if (PyErr_Occurred()) SWIG_fail;
32900 }
32901 {
32902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32903 }
32904 return resultobj;
32905 fail:
32906 return NULL;
32907 }
32908
32909
32910 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32911 PyObject *resultobj = 0;
32912 wxWindow *arg1 = (wxWindow *) 0 ;
32913 bool result;
32914 void *argp1 = 0 ;
32915 int res1 = 0 ;
32916 PyObject *swig_obj[1] ;
32917
32918 if (!args) SWIG_fail;
32919 swig_obj[0] = args;
32920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32921 if (!SWIG_IsOK(res1)) {
32922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32923 }
32924 arg1 = reinterpret_cast< wxWindow * >(argp1);
32925 {
32926 PyThreadState* __tstate = wxPyBeginAllowThreads();
32927 result = (bool)(arg1)->Disable();
32928 wxPyEndAllowThreads(__tstate);
32929 if (PyErr_Occurred()) SWIG_fail;
32930 }
32931 {
32932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32933 }
32934 return resultobj;
32935 fail:
32936 return NULL;
32937 }
32938
32939
32940 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32941 PyObject *resultobj = 0;
32942 wxWindow *arg1 = (wxWindow *) 0 ;
32943 bool result;
32944 void *argp1 = 0 ;
32945 int res1 = 0 ;
32946 PyObject *swig_obj[1] ;
32947
32948 if (!args) SWIG_fail;
32949 swig_obj[0] = args;
32950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32951 if (!SWIG_IsOK(res1)) {
32952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32953 }
32954 arg1 = reinterpret_cast< wxWindow * >(argp1);
32955 {
32956 PyThreadState* __tstate = wxPyBeginAllowThreads();
32957 result = (bool)((wxWindow const *)arg1)->IsShown();
32958 wxPyEndAllowThreads(__tstate);
32959 if (PyErr_Occurred()) SWIG_fail;
32960 }
32961 {
32962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32963 }
32964 return resultobj;
32965 fail:
32966 return NULL;
32967 }
32968
32969
32970 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32971 PyObject *resultobj = 0;
32972 wxWindow *arg1 = (wxWindow *) 0 ;
32973 bool result;
32974 void *argp1 = 0 ;
32975 int res1 = 0 ;
32976 PyObject *swig_obj[1] ;
32977
32978 if (!args) SWIG_fail;
32979 swig_obj[0] = args;
32980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32981 if (!SWIG_IsOK(res1)) {
32982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32983 }
32984 arg1 = reinterpret_cast< wxWindow * >(argp1);
32985 {
32986 PyThreadState* __tstate = wxPyBeginAllowThreads();
32987 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32988 wxPyEndAllowThreads(__tstate);
32989 if (PyErr_Occurred()) SWIG_fail;
32990 }
32991 {
32992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32993 }
32994 return resultobj;
32995 fail:
32996 return NULL;
32997 }
32998
32999
33000 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33001 PyObject *resultobj = 0;
33002 wxWindow *arg1 = (wxWindow *) 0 ;
33003 bool result;
33004 void *argp1 = 0 ;
33005 int res1 = 0 ;
33006 PyObject *swig_obj[1] ;
33007
33008 if (!args) SWIG_fail;
33009 swig_obj[0] = args;
33010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33011 if (!SWIG_IsOK(res1)) {
33012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33013 }
33014 arg1 = reinterpret_cast< wxWindow * >(argp1);
33015 {
33016 PyThreadState* __tstate = wxPyBeginAllowThreads();
33017 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33018 wxPyEndAllowThreads(__tstate);
33019 if (PyErr_Occurred()) SWIG_fail;
33020 }
33021 {
33022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33023 }
33024 return resultobj;
33025 fail:
33026 return NULL;
33027 }
33028
33029
33030 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33031 PyObject *resultobj = 0;
33032 wxWindow *arg1 = (wxWindow *) 0 ;
33033 long arg2 ;
33034 void *argp1 = 0 ;
33035 int res1 = 0 ;
33036 long val2 ;
33037 int ecode2 = 0 ;
33038 PyObject * obj0 = 0 ;
33039 PyObject * obj1 = 0 ;
33040 char * kwnames[] = {
33041 (char *) "self",(char *) "style", NULL
33042 };
33043
33044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33046 if (!SWIG_IsOK(res1)) {
33047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33048 }
33049 arg1 = reinterpret_cast< wxWindow * >(argp1);
33050 ecode2 = SWIG_AsVal_long(obj1, &val2);
33051 if (!SWIG_IsOK(ecode2)) {
33052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33053 }
33054 arg2 = static_cast< long >(val2);
33055 {
33056 PyThreadState* __tstate = wxPyBeginAllowThreads();
33057 (arg1)->SetWindowStyleFlag(arg2);
33058 wxPyEndAllowThreads(__tstate);
33059 if (PyErr_Occurred()) SWIG_fail;
33060 }
33061 resultobj = SWIG_Py_Void();
33062 return resultobj;
33063 fail:
33064 return NULL;
33065 }
33066
33067
33068 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33069 PyObject *resultobj = 0;
33070 wxWindow *arg1 = (wxWindow *) 0 ;
33071 long result;
33072 void *argp1 = 0 ;
33073 int res1 = 0 ;
33074 PyObject *swig_obj[1] ;
33075
33076 if (!args) SWIG_fail;
33077 swig_obj[0] = args;
33078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33079 if (!SWIG_IsOK(res1)) {
33080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33081 }
33082 arg1 = reinterpret_cast< wxWindow * >(argp1);
33083 {
33084 PyThreadState* __tstate = wxPyBeginAllowThreads();
33085 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33086 wxPyEndAllowThreads(__tstate);
33087 if (PyErr_Occurred()) SWIG_fail;
33088 }
33089 resultobj = SWIG_From_long(static_cast< long >(result));
33090 return resultobj;
33091 fail:
33092 return NULL;
33093 }
33094
33095
33096 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33097 PyObject *resultobj = 0;
33098 wxWindow *arg1 = (wxWindow *) 0 ;
33099 int arg2 ;
33100 bool result;
33101 void *argp1 = 0 ;
33102 int res1 = 0 ;
33103 int val2 ;
33104 int ecode2 = 0 ;
33105 PyObject * obj0 = 0 ;
33106 PyObject * obj1 = 0 ;
33107 char * kwnames[] = {
33108 (char *) "self",(char *) "flag", NULL
33109 };
33110
33111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33113 if (!SWIG_IsOK(res1)) {
33114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33115 }
33116 arg1 = reinterpret_cast< wxWindow * >(argp1);
33117 ecode2 = SWIG_AsVal_int(obj1, &val2);
33118 if (!SWIG_IsOK(ecode2)) {
33119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33120 }
33121 arg2 = static_cast< int >(val2);
33122 {
33123 PyThreadState* __tstate = wxPyBeginAllowThreads();
33124 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33125 wxPyEndAllowThreads(__tstate);
33126 if (PyErr_Occurred()) SWIG_fail;
33127 }
33128 {
33129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33130 }
33131 return resultobj;
33132 fail:
33133 return NULL;
33134 }
33135
33136
33137 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33138 PyObject *resultobj = 0;
33139 wxWindow *arg1 = (wxWindow *) 0 ;
33140 bool result;
33141 void *argp1 = 0 ;
33142 int res1 = 0 ;
33143 PyObject *swig_obj[1] ;
33144
33145 if (!args) SWIG_fail;
33146 swig_obj[0] = args;
33147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33148 if (!SWIG_IsOK(res1)) {
33149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33150 }
33151 arg1 = reinterpret_cast< wxWindow * >(argp1);
33152 {
33153 PyThreadState* __tstate = wxPyBeginAllowThreads();
33154 result = (bool)((wxWindow const *)arg1)->IsRetained();
33155 wxPyEndAllowThreads(__tstate);
33156 if (PyErr_Occurred()) SWIG_fail;
33157 }
33158 {
33159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33160 }
33161 return resultobj;
33162 fail:
33163 return NULL;
33164 }
33165
33166
33167 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33168 PyObject *resultobj = 0;
33169 wxWindow *arg1 = (wxWindow *) 0 ;
33170 long arg2 ;
33171 void *argp1 = 0 ;
33172 int res1 = 0 ;
33173 long val2 ;
33174 int ecode2 = 0 ;
33175 PyObject * obj0 = 0 ;
33176 PyObject * obj1 = 0 ;
33177 char * kwnames[] = {
33178 (char *) "self",(char *) "exStyle", NULL
33179 };
33180
33181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33183 if (!SWIG_IsOK(res1)) {
33184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33185 }
33186 arg1 = reinterpret_cast< wxWindow * >(argp1);
33187 ecode2 = SWIG_AsVal_long(obj1, &val2);
33188 if (!SWIG_IsOK(ecode2)) {
33189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33190 }
33191 arg2 = static_cast< long >(val2);
33192 {
33193 PyThreadState* __tstate = wxPyBeginAllowThreads();
33194 (arg1)->SetExtraStyle(arg2);
33195 wxPyEndAllowThreads(__tstate);
33196 if (PyErr_Occurred()) SWIG_fail;
33197 }
33198 resultobj = SWIG_Py_Void();
33199 return resultobj;
33200 fail:
33201 return NULL;
33202 }
33203
33204
33205 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33206 PyObject *resultobj = 0;
33207 wxWindow *arg1 = (wxWindow *) 0 ;
33208 long result;
33209 void *argp1 = 0 ;
33210 int res1 = 0 ;
33211 PyObject *swig_obj[1] ;
33212
33213 if (!args) SWIG_fail;
33214 swig_obj[0] = args;
33215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33216 if (!SWIG_IsOK(res1)) {
33217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33218 }
33219 arg1 = reinterpret_cast< wxWindow * >(argp1);
33220 {
33221 PyThreadState* __tstate = wxPyBeginAllowThreads();
33222 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33223 wxPyEndAllowThreads(__tstate);
33224 if (PyErr_Occurred()) SWIG_fail;
33225 }
33226 resultobj = SWIG_From_long(static_cast< long >(result));
33227 return resultobj;
33228 fail:
33229 return NULL;
33230 }
33231
33232
33233 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33234 PyObject *resultobj = 0;
33235 wxWindow *arg1 = (wxWindow *) 0 ;
33236 bool arg2 = (bool) true ;
33237 void *argp1 = 0 ;
33238 int res1 = 0 ;
33239 bool val2 ;
33240 int ecode2 = 0 ;
33241 PyObject * obj0 = 0 ;
33242 PyObject * obj1 = 0 ;
33243 char * kwnames[] = {
33244 (char *) "self",(char *) "modal", NULL
33245 };
33246
33247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33249 if (!SWIG_IsOK(res1)) {
33250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33251 }
33252 arg1 = reinterpret_cast< wxWindow * >(argp1);
33253 if (obj1) {
33254 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33255 if (!SWIG_IsOK(ecode2)) {
33256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33257 }
33258 arg2 = static_cast< bool >(val2);
33259 }
33260 {
33261 PyThreadState* __tstate = wxPyBeginAllowThreads();
33262 (arg1)->MakeModal(arg2);
33263 wxPyEndAllowThreads(__tstate);
33264 if (PyErr_Occurred()) SWIG_fail;
33265 }
33266 resultobj = SWIG_Py_Void();
33267 return resultobj;
33268 fail:
33269 return NULL;
33270 }
33271
33272
33273 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33274 PyObject *resultobj = 0;
33275 wxWindow *arg1 = (wxWindow *) 0 ;
33276 bool arg2 ;
33277 void *argp1 = 0 ;
33278 int res1 = 0 ;
33279 bool val2 ;
33280 int ecode2 = 0 ;
33281 PyObject * obj0 = 0 ;
33282 PyObject * obj1 = 0 ;
33283 char * kwnames[] = {
33284 (char *) "self",(char *) "enableTheme", NULL
33285 };
33286
33287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33289 if (!SWIG_IsOK(res1)) {
33290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33291 }
33292 arg1 = reinterpret_cast< wxWindow * >(argp1);
33293 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33294 if (!SWIG_IsOK(ecode2)) {
33295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33296 }
33297 arg2 = static_cast< bool >(val2);
33298 {
33299 PyThreadState* __tstate = wxPyBeginAllowThreads();
33300 (arg1)->SetThemeEnabled(arg2);
33301 wxPyEndAllowThreads(__tstate);
33302 if (PyErr_Occurred()) SWIG_fail;
33303 }
33304 resultobj = SWIG_Py_Void();
33305 return resultobj;
33306 fail:
33307 return NULL;
33308 }
33309
33310
33311 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33312 PyObject *resultobj = 0;
33313 wxWindow *arg1 = (wxWindow *) 0 ;
33314 bool result;
33315 void *argp1 = 0 ;
33316 int res1 = 0 ;
33317 PyObject *swig_obj[1] ;
33318
33319 if (!args) SWIG_fail;
33320 swig_obj[0] = args;
33321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33322 if (!SWIG_IsOK(res1)) {
33323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33324 }
33325 arg1 = reinterpret_cast< wxWindow * >(argp1);
33326 {
33327 PyThreadState* __tstate = wxPyBeginAllowThreads();
33328 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33329 wxPyEndAllowThreads(__tstate);
33330 if (PyErr_Occurred()) SWIG_fail;
33331 }
33332 {
33333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33334 }
33335 return resultobj;
33336 fail:
33337 return NULL;
33338 }
33339
33340
33341 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33342 PyObject *resultobj = 0;
33343 wxWindow *arg1 = (wxWindow *) 0 ;
33344 void *argp1 = 0 ;
33345 int res1 = 0 ;
33346 PyObject *swig_obj[1] ;
33347
33348 if (!args) SWIG_fail;
33349 swig_obj[0] = args;
33350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33351 if (!SWIG_IsOK(res1)) {
33352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33353 }
33354 arg1 = reinterpret_cast< wxWindow * >(argp1);
33355 {
33356 PyThreadState* __tstate = wxPyBeginAllowThreads();
33357 (arg1)->SetFocus();
33358 wxPyEndAllowThreads(__tstate);
33359 if (PyErr_Occurred()) SWIG_fail;
33360 }
33361 resultobj = SWIG_Py_Void();
33362 return resultobj;
33363 fail:
33364 return NULL;
33365 }
33366
33367
33368 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33369 PyObject *resultobj = 0;
33370 wxWindow *arg1 = (wxWindow *) 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_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33380 }
33381 arg1 = reinterpret_cast< wxWindow * >(argp1);
33382 {
33383 PyThreadState* __tstate = wxPyBeginAllowThreads();
33384 (arg1)->SetFocusFromKbd();
33385 wxPyEndAllowThreads(__tstate);
33386 if (PyErr_Occurred()) SWIG_fail;
33387 }
33388 resultobj = SWIG_Py_Void();
33389 return resultobj;
33390 fail:
33391 return NULL;
33392 }
33393
33394
33395 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33396 PyObject *resultobj = 0;
33397 wxWindow *result = 0 ;
33398
33399 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33400 {
33401 if (!wxPyCheckForApp()) SWIG_fail;
33402 PyThreadState* __tstate = wxPyBeginAllowThreads();
33403 result = (wxWindow *)wxWindow::FindFocus();
33404 wxPyEndAllowThreads(__tstate);
33405 if (PyErr_Occurred()) SWIG_fail;
33406 }
33407 {
33408 resultobj = wxPyMake_wxObject(result, 0);
33409 }
33410 return resultobj;
33411 fail:
33412 return NULL;
33413 }
33414
33415
33416 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33417 PyObject *resultobj = 0;
33418 wxWindow *arg1 = (wxWindow *) 0 ;
33419 bool result;
33420 void *argp1 = 0 ;
33421 int res1 = 0 ;
33422 PyObject *swig_obj[1] ;
33423
33424 if (!args) SWIG_fail;
33425 swig_obj[0] = args;
33426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33427 if (!SWIG_IsOK(res1)) {
33428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33429 }
33430 arg1 = reinterpret_cast< wxWindow * >(argp1);
33431 {
33432 PyThreadState* __tstate = wxPyBeginAllowThreads();
33433 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33434 wxPyEndAllowThreads(__tstate);
33435 if (PyErr_Occurred()) SWIG_fail;
33436 }
33437 {
33438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33439 }
33440 return resultobj;
33441 fail:
33442 return NULL;
33443 }
33444
33445
33446 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33447 PyObject *resultobj = 0;
33448 wxWindow *arg1 = (wxWindow *) 0 ;
33449 bool result;
33450 void *argp1 = 0 ;
33451 int res1 = 0 ;
33452 PyObject *swig_obj[1] ;
33453
33454 if (!args) SWIG_fail;
33455 swig_obj[0] = args;
33456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33457 if (!SWIG_IsOK(res1)) {
33458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33459 }
33460 arg1 = reinterpret_cast< wxWindow * >(argp1);
33461 {
33462 PyThreadState* __tstate = wxPyBeginAllowThreads();
33463 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33464 wxPyEndAllowThreads(__tstate);
33465 if (PyErr_Occurred()) SWIG_fail;
33466 }
33467 {
33468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33469 }
33470 return resultobj;
33471 fail:
33472 return NULL;
33473 }
33474
33475
33476 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33477 PyObject *resultobj = 0;
33478 wxWindow *arg1 = (wxWindow *) 0 ;
33479 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33480 bool result;
33481 void *argp1 = 0 ;
33482 int res1 = 0 ;
33483 int val2 ;
33484 int ecode2 = 0 ;
33485 PyObject * obj0 = 0 ;
33486 PyObject * obj1 = 0 ;
33487 char * kwnames[] = {
33488 (char *) "self",(char *) "flags", NULL
33489 };
33490
33491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33493 if (!SWIG_IsOK(res1)) {
33494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33495 }
33496 arg1 = reinterpret_cast< wxWindow * >(argp1);
33497 if (obj1) {
33498 ecode2 = SWIG_AsVal_int(obj1, &val2);
33499 if (!SWIG_IsOK(ecode2)) {
33500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33501 }
33502 arg2 = static_cast< int >(val2);
33503 }
33504 {
33505 PyThreadState* __tstate = wxPyBeginAllowThreads();
33506 result = (bool)(arg1)->Navigate(arg2);
33507 wxPyEndAllowThreads(__tstate);
33508 if (PyErr_Occurred()) SWIG_fail;
33509 }
33510 {
33511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33512 }
33513 return resultobj;
33514 fail:
33515 return NULL;
33516 }
33517
33518
33519 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33520 PyObject *resultobj = 0;
33521 wxWindow *arg1 = (wxWindow *) 0 ;
33522 wxWindow *arg2 = (wxWindow *) 0 ;
33523 void *argp1 = 0 ;
33524 int res1 = 0 ;
33525 void *argp2 = 0 ;
33526 int res2 = 0 ;
33527 PyObject * obj0 = 0 ;
33528 PyObject * obj1 = 0 ;
33529 char * kwnames[] = {
33530 (char *) "self",(char *) "win", NULL
33531 };
33532
33533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33535 if (!SWIG_IsOK(res1)) {
33536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33537 }
33538 arg1 = reinterpret_cast< wxWindow * >(argp1);
33539 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33540 if (!SWIG_IsOK(res2)) {
33541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33542 }
33543 arg2 = reinterpret_cast< wxWindow * >(argp2);
33544 {
33545 PyThreadState* __tstate = wxPyBeginAllowThreads();
33546 (arg1)->MoveAfterInTabOrder(arg2);
33547 wxPyEndAllowThreads(__tstate);
33548 if (PyErr_Occurred()) SWIG_fail;
33549 }
33550 resultobj = SWIG_Py_Void();
33551 return resultobj;
33552 fail:
33553 return NULL;
33554 }
33555
33556
33557 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33558 PyObject *resultobj = 0;
33559 wxWindow *arg1 = (wxWindow *) 0 ;
33560 wxWindow *arg2 = (wxWindow *) 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 *) "win", NULL
33569 };
33570
33571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",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_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33575 }
33576 arg1 = reinterpret_cast< wxWindow * >(argp1);
33577 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33578 if (!SWIG_IsOK(res2)) {
33579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33580 }
33581 arg2 = reinterpret_cast< wxWindow * >(argp2);
33582 {
33583 PyThreadState* __tstate = wxPyBeginAllowThreads();
33584 (arg1)->MoveBeforeInTabOrder(arg2);
33585 wxPyEndAllowThreads(__tstate);
33586 if (PyErr_Occurred()) SWIG_fail;
33587 }
33588 resultobj = SWIG_Py_Void();
33589 return resultobj;
33590 fail:
33591 return NULL;
33592 }
33593
33594
33595 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33596 PyObject *resultobj = 0;
33597 wxWindow *arg1 = (wxWindow *) 0 ;
33598 PyObject *result = 0 ;
33599 void *argp1 = 0 ;
33600 int res1 = 0 ;
33601 PyObject *swig_obj[1] ;
33602
33603 if (!args) SWIG_fail;
33604 swig_obj[0] = args;
33605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33606 if (!SWIG_IsOK(res1)) {
33607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33608 }
33609 arg1 = reinterpret_cast< wxWindow * >(argp1);
33610 {
33611 PyThreadState* __tstate = wxPyBeginAllowThreads();
33612 result = (PyObject *)wxWindow_GetChildren(arg1);
33613 wxPyEndAllowThreads(__tstate);
33614 if (PyErr_Occurred()) SWIG_fail;
33615 }
33616 resultobj = result;
33617 return resultobj;
33618 fail:
33619 return NULL;
33620 }
33621
33622
33623 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33624 PyObject *resultobj = 0;
33625 wxWindow *arg1 = (wxWindow *) 0 ;
33626 wxWindow *result = 0 ;
33627 void *argp1 = 0 ;
33628 int res1 = 0 ;
33629 PyObject *swig_obj[1] ;
33630
33631 if (!args) SWIG_fail;
33632 swig_obj[0] = args;
33633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33634 if (!SWIG_IsOK(res1)) {
33635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33636 }
33637 arg1 = reinterpret_cast< wxWindow * >(argp1);
33638 {
33639 PyThreadState* __tstate = wxPyBeginAllowThreads();
33640 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33641 wxPyEndAllowThreads(__tstate);
33642 if (PyErr_Occurred()) SWIG_fail;
33643 }
33644 {
33645 resultobj = wxPyMake_wxObject(result, 0);
33646 }
33647 return resultobj;
33648 fail:
33649 return NULL;
33650 }
33651
33652
33653 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33654 PyObject *resultobj = 0;
33655 wxWindow *arg1 = (wxWindow *) 0 ;
33656 wxWindow *result = 0 ;
33657 void *argp1 = 0 ;
33658 int res1 = 0 ;
33659 PyObject *swig_obj[1] ;
33660
33661 if (!args) SWIG_fail;
33662 swig_obj[0] = args;
33663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33664 if (!SWIG_IsOK(res1)) {
33665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33666 }
33667 arg1 = reinterpret_cast< wxWindow * >(argp1);
33668 {
33669 PyThreadState* __tstate = wxPyBeginAllowThreads();
33670 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33671 wxPyEndAllowThreads(__tstate);
33672 if (PyErr_Occurred()) SWIG_fail;
33673 }
33674 {
33675 resultobj = wxPyMake_wxObject(result, 0);
33676 }
33677 return resultobj;
33678 fail:
33679 return NULL;
33680 }
33681
33682
33683 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33684 PyObject *resultobj = 0;
33685 wxWindow *arg1 = (wxWindow *) 0 ;
33686 bool result;
33687 void *argp1 = 0 ;
33688 int res1 = 0 ;
33689 PyObject *swig_obj[1] ;
33690
33691 if (!args) SWIG_fail;
33692 swig_obj[0] = args;
33693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33694 if (!SWIG_IsOK(res1)) {
33695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33696 }
33697 arg1 = reinterpret_cast< wxWindow * >(argp1);
33698 {
33699 PyThreadState* __tstate = wxPyBeginAllowThreads();
33700 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33701 wxPyEndAllowThreads(__tstate);
33702 if (PyErr_Occurred()) SWIG_fail;
33703 }
33704 {
33705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33706 }
33707 return resultobj;
33708 fail:
33709 return NULL;
33710 }
33711
33712
33713 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33714 PyObject *resultobj = 0;
33715 wxWindow *arg1 = (wxWindow *) 0 ;
33716 wxWindow *arg2 = (wxWindow *) 0 ;
33717 bool result;
33718 void *argp1 = 0 ;
33719 int res1 = 0 ;
33720 void *argp2 = 0 ;
33721 int res2 = 0 ;
33722 PyObject * obj0 = 0 ;
33723 PyObject * obj1 = 0 ;
33724 char * kwnames[] = {
33725 (char *) "self",(char *) "newParent", NULL
33726 };
33727
33728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33730 if (!SWIG_IsOK(res1)) {
33731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33732 }
33733 arg1 = reinterpret_cast< wxWindow * >(argp1);
33734 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33735 if (!SWIG_IsOK(res2)) {
33736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33737 }
33738 arg2 = reinterpret_cast< wxWindow * >(argp2);
33739 {
33740 PyThreadState* __tstate = wxPyBeginAllowThreads();
33741 result = (bool)(arg1)->Reparent(arg2);
33742 wxPyEndAllowThreads(__tstate);
33743 if (PyErr_Occurred()) SWIG_fail;
33744 }
33745 {
33746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33747 }
33748 return resultobj;
33749 fail:
33750 return NULL;
33751 }
33752
33753
33754 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33755 PyObject *resultobj = 0;
33756 wxWindow *arg1 = (wxWindow *) 0 ;
33757 wxWindow *arg2 = (wxWindow *) 0 ;
33758 void *argp1 = 0 ;
33759 int res1 = 0 ;
33760 void *argp2 = 0 ;
33761 int res2 = 0 ;
33762 PyObject * obj0 = 0 ;
33763 PyObject * obj1 = 0 ;
33764 char * kwnames[] = {
33765 (char *) "self",(char *) "child", NULL
33766 };
33767
33768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33770 if (!SWIG_IsOK(res1)) {
33771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33772 }
33773 arg1 = reinterpret_cast< wxWindow * >(argp1);
33774 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33775 if (!SWIG_IsOK(res2)) {
33776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33777 }
33778 arg2 = reinterpret_cast< wxWindow * >(argp2);
33779 {
33780 PyThreadState* __tstate = wxPyBeginAllowThreads();
33781 (arg1)->AddChild(arg2);
33782 wxPyEndAllowThreads(__tstate);
33783 if (PyErr_Occurred()) SWIG_fail;
33784 }
33785 resultobj = SWIG_Py_Void();
33786 return resultobj;
33787 fail:
33788 return NULL;
33789 }
33790
33791
33792 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33793 PyObject *resultobj = 0;
33794 wxWindow *arg1 = (wxWindow *) 0 ;
33795 wxWindow *arg2 = (wxWindow *) 0 ;
33796 void *argp1 = 0 ;
33797 int res1 = 0 ;
33798 void *argp2 = 0 ;
33799 int res2 = 0 ;
33800 PyObject * obj0 = 0 ;
33801 PyObject * obj1 = 0 ;
33802 char * kwnames[] = {
33803 (char *) "self",(char *) "child", NULL
33804 };
33805
33806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33808 if (!SWIG_IsOK(res1)) {
33809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33810 }
33811 arg1 = reinterpret_cast< wxWindow * >(argp1);
33812 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33813 if (!SWIG_IsOK(res2)) {
33814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33815 }
33816 arg2 = reinterpret_cast< wxWindow * >(argp2);
33817 {
33818 PyThreadState* __tstate = wxPyBeginAllowThreads();
33819 (arg1)->RemoveChild(arg2);
33820 wxPyEndAllowThreads(__tstate);
33821 if (PyErr_Occurred()) SWIG_fail;
33822 }
33823 resultobj = SWIG_Py_Void();
33824 return resultobj;
33825 fail:
33826 return NULL;
33827 }
33828
33829
33830 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33831 PyObject *resultobj = 0;
33832 wxWindow *arg1 = (wxWindow *) 0 ;
33833 bool arg2 ;
33834 void *argp1 = 0 ;
33835 int res1 = 0 ;
33836 bool val2 ;
33837 int ecode2 = 0 ;
33838 PyObject * obj0 = 0 ;
33839 PyObject * obj1 = 0 ;
33840 char * kwnames[] = {
33841 (char *) "self",(char *) "on", NULL
33842 };
33843
33844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33846 if (!SWIG_IsOK(res1)) {
33847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33848 }
33849 arg1 = reinterpret_cast< wxWindow * >(argp1);
33850 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33851 if (!SWIG_IsOK(ecode2)) {
33852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33853 }
33854 arg2 = static_cast< bool >(val2);
33855 {
33856 PyThreadState* __tstate = wxPyBeginAllowThreads();
33857 wxWindow_SetDoubleBuffered(arg1,arg2);
33858 wxPyEndAllowThreads(__tstate);
33859 if (PyErr_Occurred()) SWIG_fail;
33860 }
33861 resultobj = SWIG_Py_Void();
33862 return resultobj;
33863 fail:
33864 return NULL;
33865 }
33866
33867
33868 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33869 PyObject *resultobj = 0;
33870 wxWindow *arg1 = (wxWindow *) 0 ;
33871 long arg2 ;
33872 wxWindow *result = 0 ;
33873 void *argp1 = 0 ;
33874 int res1 = 0 ;
33875 long val2 ;
33876 int ecode2 = 0 ;
33877 PyObject * obj0 = 0 ;
33878 PyObject * obj1 = 0 ;
33879 char * kwnames[] = {
33880 (char *) "self",(char *) "winid", NULL
33881 };
33882
33883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33885 if (!SWIG_IsOK(res1)) {
33886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33887 }
33888 arg1 = reinterpret_cast< wxWindow * >(argp1);
33889 ecode2 = SWIG_AsVal_long(obj1, &val2);
33890 if (!SWIG_IsOK(ecode2)) {
33891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33892 }
33893 arg2 = static_cast< long >(val2);
33894 {
33895 PyThreadState* __tstate = wxPyBeginAllowThreads();
33896 result = (wxWindow *)(arg1)->FindWindow(arg2);
33897 wxPyEndAllowThreads(__tstate);
33898 if (PyErr_Occurred()) SWIG_fail;
33899 }
33900 {
33901 resultobj = wxPyMake_wxObject(result, 0);
33902 }
33903 return resultobj;
33904 fail:
33905 return NULL;
33906 }
33907
33908
33909 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33910 PyObject *resultobj = 0;
33911 wxWindow *arg1 = (wxWindow *) 0 ;
33912 wxString *arg2 = 0 ;
33913 wxWindow *result = 0 ;
33914 void *argp1 = 0 ;
33915 int res1 = 0 ;
33916 bool temp2 = false ;
33917 PyObject * obj0 = 0 ;
33918 PyObject * obj1 = 0 ;
33919 char * kwnames[] = {
33920 (char *) "self",(char *) "name", NULL
33921 };
33922
33923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33925 if (!SWIG_IsOK(res1)) {
33926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33927 }
33928 arg1 = reinterpret_cast< wxWindow * >(argp1);
33929 {
33930 arg2 = wxString_in_helper(obj1);
33931 if (arg2 == NULL) SWIG_fail;
33932 temp2 = true;
33933 }
33934 {
33935 PyThreadState* __tstate = wxPyBeginAllowThreads();
33936 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33937 wxPyEndAllowThreads(__tstate);
33938 if (PyErr_Occurred()) SWIG_fail;
33939 }
33940 {
33941 resultobj = wxPyMake_wxObject(result, 0);
33942 }
33943 {
33944 if (temp2)
33945 delete arg2;
33946 }
33947 return resultobj;
33948 fail:
33949 {
33950 if (temp2)
33951 delete arg2;
33952 }
33953 return NULL;
33954 }
33955
33956
33957 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33958 PyObject *resultobj = 0;
33959 wxWindow *arg1 = (wxWindow *) 0 ;
33960 wxEvtHandler *result = 0 ;
33961 void *argp1 = 0 ;
33962 int res1 = 0 ;
33963 PyObject *swig_obj[1] ;
33964
33965 if (!args) SWIG_fail;
33966 swig_obj[0] = args;
33967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33968 if (!SWIG_IsOK(res1)) {
33969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33970 }
33971 arg1 = reinterpret_cast< wxWindow * >(argp1);
33972 {
33973 PyThreadState* __tstate = wxPyBeginAllowThreads();
33974 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33975 wxPyEndAllowThreads(__tstate);
33976 if (PyErr_Occurred()) SWIG_fail;
33977 }
33978 {
33979 resultobj = wxPyMake_wxObject(result, 0);
33980 }
33981 return resultobj;
33982 fail:
33983 return NULL;
33984 }
33985
33986
33987 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33988 PyObject *resultobj = 0;
33989 wxWindow *arg1 = (wxWindow *) 0 ;
33990 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33991 void *argp1 = 0 ;
33992 int res1 = 0 ;
33993 void *argp2 = 0 ;
33994 int res2 = 0 ;
33995 PyObject * obj0 = 0 ;
33996 PyObject * obj1 = 0 ;
33997 char * kwnames[] = {
33998 (char *) "self",(char *) "handler", NULL
33999 };
34000
34001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34003 if (!SWIG_IsOK(res1)) {
34004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34005 }
34006 arg1 = reinterpret_cast< wxWindow * >(argp1);
34007 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34008 if (!SWIG_IsOK(res2)) {
34009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34010 }
34011 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34012 {
34013 PyThreadState* __tstate = wxPyBeginAllowThreads();
34014 (arg1)->SetEventHandler(arg2);
34015 wxPyEndAllowThreads(__tstate);
34016 if (PyErr_Occurred()) SWIG_fail;
34017 }
34018 resultobj = SWIG_Py_Void();
34019 return resultobj;
34020 fail:
34021 return NULL;
34022 }
34023
34024
34025 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34026 PyObject *resultobj = 0;
34027 wxWindow *arg1 = (wxWindow *) 0 ;
34028 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34029 void *argp1 = 0 ;
34030 int res1 = 0 ;
34031 void *argp2 = 0 ;
34032 int res2 = 0 ;
34033 PyObject * obj0 = 0 ;
34034 PyObject * obj1 = 0 ;
34035 char * kwnames[] = {
34036 (char *) "self",(char *) "handler", NULL
34037 };
34038
34039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",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_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34043 }
34044 arg1 = reinterpret_cast< wxWindow * >(argp1);
34045 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34046 if (!SWIG_IsOK(res2)) {
34047 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34048 }
34049 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34050 {
34051 PyThreadState* __tstate = wxPyBeginAllowThreads();
34052 (arg1)->PushEventHandler(arg2);
34053 wxPyEndAllowThreads(__tstate);
34054 if (PyErr_Occurred()) SWIG_fail;
34055 }
34056 resultobj = SWIG_Py_Void();
34057 return resultobj;
34058 fail:
34059 return NULL;
34060 }
34061
34062
34063 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34064 PyObject *resultobj = 0;
34065 wxWindow *arg1 = (wxWindow *) 0 ;
34066 bool arg2 = (bool) false ;
34067 wxEvtHandler *result = 0 ;
34068 void *argp1 = 0 ;
34069 int res1 = 0 ;
34070 bool val2 ;
34071 int ecode2 = 0 ;
34072 PyObject * obj0 = 0 ;
34073 PyObject * obj1 = 0 ;
34074 char * kwnames[] = {
34075 (char *) "self",(char *) "deleteHandler", NULL
34076 };
34077
34078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34080 if (!SWIG_IsOK(res1)) {
34081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34082 }
34083 arg1 = reinterpret_cast< wxWindow * >(argp1);
34084 if (obj1) {
34085 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34086 if (!SWIG_IsOK(ecode2)) {
34087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34088 }
34089 arg2 = static_cast< bool >(val2);
34090 }
34091 {
34092 PyThreadState* __tstate = wxPyBeginAllowThreads();
34093 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34094 wxPyEndAllowThreads(__tstate);
34095 if (PyErr_Occurred()) SWIG_fail;
34096 }
34097 {
34098 resultobj = wxPyMake_wxObject(result, 0);
34099 }
34100 return resultobj;
34101 fail:
34102 return NULL;
34103 }
34104
34105
34106 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34107 PyObject *resultobj = 0;
34108 wxWindow *arg1 = (wxWindow *) 0 ;
34109 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34110 bool result;
34111 void *argp1 = 0 ;
34112 int res1 = 0 ;
34113 void *argp2 = 0 ;
34114 int res2 = 0 ;
34115 PyObject * obj0 = 0 ;
34116 PyObject * obj1 = 0 ;
34117 char * kwnames[] = {
34118 (char *) "self",(char *) "handler", NULL
34119 };
34120
34121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34123 if (!SWIG_IsOK(res1)) {
34124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34125 }
34126 arg1 = reinterpret_cast< wxWindow * >(argp1);
34127 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34128 if (!SWIG_IsOK(res2)) {
34129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34130 }
34131 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34132 {
34133 PyThreadState* __tstate = wxPyBeginAllowThreads();
34134 result = (bool)(arg1)->RemoveEventHandler(arg2);
34135 wxPyEndAllowThreads(__tstate);
34136 if (PyErr_Occurred()) SWIG_fail;
34137 }
34138 {
34139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34140 }
34141 return resultobj;
34142 fail:
34143 return NULL;
34144 }
34145
34146
34147 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34148 PyObject *resultobj = 0;
34149 wxWindow *arg1 = (wxWindow *) 0 ;
34150 wxValidator *arg2 = 0 ;
34151 void *argp1 = 0 ;
34152 int res1 = 0 ;
34153 void *argp2 = 0 ;
34154 int res2 = 0 ;
34155 PyObject * obj0 = 0 ;
34156 PyObject * obj1 = 0 ;
34157 char * kwnames[] = {
34158 (char *) "self",(char *) "validator", NULL
34159 };
34160
34161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34163 if (!SWIG_IsOK(res1)) {
34164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34165 }
34166 arg1 = reinterpret_cast< wxWindow * >(argp1);
34167 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34168 if (!SWIG_IsOK(res2)) {
34169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34170 }
34171 if (!argp2) {
34172 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34173 }
34174 arg2 = reinterpret_cast< wxValidator * >(argp2);
34175 {
34176 PyThreadState* __tstate = wxPyBeginAllowThreads();
34177 (arg1)->SetValidator((wxValidator const &)*arg2);
34178 wxPyEndAllowThreads(__tstate);
34179 if (PyErr_Occurred()) SWIG_fail;
34180 }
34181 resultobj = SWIG_Py_Void();
34182 return resultobj;
34183 fail:
34184 return NULL;
34185 }
34186
34187
34188 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34189 PyObject *resultobj = 0;
34190 wxWindow *arg1 = (wxWindow *) 0 ;
34191 wxValidator *result = 0 ;
34192 void *argp1 = 0 ;
34193 int res1 = 0 ;
34194 PyObject *swig_obj[1] ;
34195
34196 if (!args) SWIG_fail;
34197 swig_obj[0] = args;
34198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34199 if (!SWIG_IsOK(res1)) {
34200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34201 }
34202 arg1 = reinterpret_cast< wxWindow * >(argp1);
34203 {
34204 PyThreadState* __tstate = wxPyBeginAllowThreads();
34205 result = (wxValidator *)(arg1)->GetValidator();
34206 wxPyEndAllowThreads(__tstate);
34207 if (PyErr_Occurred()) SWIG_fail;
34208 }
34209 {
34210 resultobj = wxPyMake_wxObject(result, (bool)0);
34211 }
34212 return resultobj;
34213 fail:
34214 return NULL;
34215 }
34216
34217
34218 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34219 PyObject *resultobj = 0;
34220 wxWindow *arg1 = (wxWindow *) 0 ;
34221 bool result;
34222 void *argp1 = 0 ;
34223 int res1 = 0 ;
34224 PyObject *swig_obj[1] ;
34225
34226 if (!args) SWIG_fail;
34227 swig_obj[0] = args;
34228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34229 if (!SWIG_IsOK(res1)) {
34230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34231 }
34232 arg1 = reinterpret_cast< wxWindow * >(argp1);
34233 {
34234 PyThreadState* __tstate = wxPyBeginAllowThreads();
34235 result = (bool)(arg1)->Validate();
34236 wxPyEndAllowThreads(__tstate);
34237 if (PyErr_Occurred()) SWIG_fail;
34238 }
34239 {
34240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34241 }
34242 return resultobj;
34243 fail:
34244 return NULL;
34245 }
34246
34247
34248 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34249 PyObject *resultobj = 0;
34250 wxWindow *arg1 = (wxWindow *) 0 ;
34251 bool result;
34252 void *argp1 = 0 ;
34253 int res1 = 0 ;
34254 PyObject *swig_obj[1] ;
34255
34256 if (!args) SWIG_fail;
34257 swig_obj[0] = args;
34258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34259 if (!SWIG_IsOK(res1)) {
34260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34261 }
34262 arg1 = reinterpret_cast< wxWindow * >(argp1);
34263 {
34264 PyThreadState* __tstate = wxPyBeginAllowThreads();
34265 result = (bool)(arg1)->TransferDataToWindow();
34266 wxPyEndAllowThreads(__tstate);
34267 if (PyErr_Occurred()) SWIG_fail;
34268 }
34269 {
34270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34271 }
34272 return resultobj;
34273 fail:
34274 return NULL;
34275 }
34276
34277
34278 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34279 PyObject *resultobj = 0;
34280 wxWindow *arg1 = (wxWindow *) 0 ;
34281 bool result;
34282 void *argp1 = 0 ;
34283 int res1 = 0 ;
34284 PyObject *swig_obj[1] ;
34285
34286 if (!args) SWIG_fail;
34287 swig_obj[0] = args;
34288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34289 if (!SWIG_IsOK(res1)) {
34290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34291 }
34292 arg1 = reinterpret_cast< wxWindow * >(argp1);
34293 {
34294 PyThreadState* __tstate = wxPyBeginAllowThreads();
34295 result = (bool)(arg1)->TransferDataFromWindow();
34296 wxPyEndAllowThreads(__tstate);
34297 if (PyErr_Occurred()) SWIG_fail;
34298 }
34299 {
34300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34301 }
34302 return resultobj;
34303 fail:
34304 return NULL;
34305 }
34306
34307
34308 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34309 PyObject *resultobj = 0;
34310 wxWindow *arg1 = (wxWindow *) 0 ;
34311 void *argp1 = 0 ;
34312 int res1 = 0 ;
34313 PyObject *swig_obj[1] ;
34314
34315 if (!args) SWIG_fail;
34316 swig_obj[0] = args;
34317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34318 if (!SWIG_IsOK(res1)) {
34319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34320 }
34321 arg1 = reinterpret_cast< wxWindow * >(argp1);
34322 {
34323 PyThreadState* __tstate = wxPyBeginAllowThreads();
34324 (arg1)->InitDialog();
34325 wxPyEndAllowThreads(__tstate);
34326 if (PyErr_Occurred()) SWIG_fail;
34327 }
34328 resultobj = SWIG_Py_Void();
34329 return resultobj;
34330 fail:
34331 return NULL;
34332 }
34333
34334
34335 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34336 PyObject *resultobj = 0;
34337 wxWindow *arg1 = (wxWindow *) 0 ;
34338 wxAcceleratorTable *arg2 = 0 ;
34339 void *argp1 = 0 ;
34340 int res1 = 0 ;
34341 void *argp2 = 0 ;
34342 int res2 = 0 ;
34343 PyObject * obj0 = 0 ;
34344 PyObject * obj1 = 0 ;
34345 char * kwnames[] = {
34346 (char *) "self",(char *) "accel", NULL
34347 };
34348
34349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34351 if (!SWIG_IsOK(res1)) {
34352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34353 }
34354 arg1 = reinterpret_cast< wxWindow * >(argp1);
34355 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34356 if (!SWIG_IsOK(res2)) {
34357 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34358 }
34359 if (!argp2) {
34360 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34361 }
34362 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34363 {
34364 PyThreadState* __tstate = wxPyBeginAllowThreads();
34365 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34366 wxPyEndAllowThreads(__tstate);
34367 if (PyErr_Occurred()) SWIG_fail;
34368 }
34369 resultobj = SWIG_Py_Void();
34370 return resultobj;
34371 fail:
34372 return NULL;
34373 }
34374
34375
34376 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34377 PyObject *resultobj = 0;
34378 wxWindow *arg1 = (wxWindow *) 0 ;
34379 wxAcceleratorTable *result = 0 ;
34380 void *argp1 = 0 ;
34381 int res1 = 0 ;
34382 PyObject *swig_obj[1] ;
34383
34384 if (!args) SWIG_fail;
34385 swig_obj[0] = args;
34386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34387 if (!SWIG_IsOK(res1)) {
34388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34389 }
34390 arg1 = reinterpret_cast< wxWindow * >(argp1);
34391 {
34392 PyThreadState* __tstate = wxPyBeginAllowThreads();
34393 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34394 wxPyEndAllowThreads(__tstate);
34395 if (PyErr_Occurred()) SWIG_fail;
34396 }
34397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34398 return resultobj;
34399 fail:
34400 return NULL;
34401 }
34402
34403
34404 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34405 PyObject *resultobj = 0;
34406 wxWindow *arg1 = (wxWindow *) 0 ;
34407 int arg2 ;
34408 int arg3 ;
34409 int arg4 ;
34410 bool result;
34411 void *argp1 = 0 ;
34412 int res1 = 0 ;
34413 int val2 ;
34414 int ecode2 = 0 ;
34415 int val3 ;
34416 int ecode3 = 0 ;
34417 int val4 ;
34418 int ecode4 = 0 ;
34419 PyObject * obj0 = 0 ;
34420 PyObject * obj1 = 0 ;
34421 PyObject * obj2 = 0 ;
34422 PyObject * obj3 = 0 ;
34423 char * kwnames[] = {
34424 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34425 };
34426
34427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34429 if (!SWIG_IsOK(res1)) {
34430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34431 }
34432 arg1 = reinterpret_cast< wxWindow * >(argp1);
34433 ecode2 = SWIG_AsVal_int(obj1, &val2);
34434 if (!SWIG_IsOK(ecode2)) {
34435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34436 }
34437 arg2 = static_cast< int >(val2);
34438 ecode3 = SWIG_AsVal_int(obj2, &val3);
34439 if (!SWIG_IsOK(ecode3)) {
34440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34441 }
34442 arg3 = static_cast< int >(val3);
34443 ecode4 = SWIG_AsVal_int(obj3, &val4);
34444 if (!SWIG_IsOK(ecode4)) {
34445 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34446 }
34447 arg4 = static_cast< int >(val4);
34448 {
34449 PyThreadState* __tstate = wxPyBeginAllowThreads();
34450 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34451 wxPyEndAllowThreads(__tstate);
34452 if (PyErr_Occurred()) SWIG_fail;
34453 }
34454 {
34455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34456 }
34457 return resultobj;
34458 fail:
34459 return NULL;
34460 }
34461
34462
34463 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34464 PyObject *resultobj = 0;
34465 wxWindow *arg1 = (wxWindow *) 0 ;
34466 int arg2 ;
34467 bool result;
34468 void *argp1 = 0 ;
34469 int res1 = 0 ;
34470 int val2 ;
34471 int ecode2 = 0 ;
34472 PyObject * obj0 = 0 ;
34473 PyObject * obj1 = 0 ;
34474 char * kwnames[] = {
34475 (char *) "self",(char *) "hotkeyId", NULL
34476 };
34477
34478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34480 if (!SWIG_IsOK(res1)) {
34481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34482 }
34483 arg1 = reinterpret_cast< wxWindow * >(argp1);
34484 ecode2 = SWIG_AsVal_int(obj1, &val2);
34485 if (!SWIG_IsOK(ecode2)) {
34486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34487 }
34488 arg2 = static_cast< int >(val2);
34489 {
34490 PyThreadState* __tstate = wxPyBeginAllowThreads();
34491 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34492 wxPyEndAllowThreads(__tstate);
34493 if (PyErr_Occurred()) SWIG_fail;
34494 }
34495 {
34496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34497 }
34498 return resultobj;
34499 fail:
34500 return NULL;
34501 }
34502
34503
34504 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34505 PyObject *resultobj = 0;
34506 wxWindow *arg1 = (wxWindow *) 0 ;
34507 wxPoint *arg2 = 0 ;
34508 wxPoint result;
34509 void *argp1 = 0 ;
34510 int res1 = 0 ;
34511 wxPoint temp2 ;
34512 PyObject * obj0 = 0 ;
34513 PyObject * obj1 = 0 ;
34514 char * kwnames[] = {
34515 (char *) "self",(char *) "pt", NULL
34516 };
34517
34518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34520 if (!SWIG_IsOK(res1)) {
34521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34522 }
34523 arg1 = reinterpret_cast< wxWindow * >(argp1);
34524 {
34525 arg2 = &temp2;
34526 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34527 }
34528 {
34529 PyThreadState* __tstate = wxPyBeginAllowThreads();
34530 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34531 wxPyEndAllowThreads(__tstate);
34532 if (PyErr_Occurred()) SWIG_fail;
34533 }
34534 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34535 return resultobj;
34536 fail:
34537 return NULL;
34538 }
34539
34540
34541 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34542 PyObject *resultobj = 0;
34543 wxWindow *arg1 = (wxWindow *) 0 ;
34544 wxSize *arg2 = 0 ;
34545 wxSize result;
34546 void *argp1 = 0 ;
34547 int res1 = 0 ;
34548 wxSize temp2 ;
34549 PyObject * obj0 = 0 ;
34550 PyObject * obj1 = 0 ;
34551 char * kwnames[] = {
34552 (char *) "self",(char *) "sz", NULL
34553 };
34554
34555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34557 if (!SWIG_IsOK(res1)) {
34558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34559 }
34560 arg1 = reinterpret_cast< wxWindow * >(argp1);
34561 {
34562 arg2 = &temp2;
34563 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34564 }
34565 {
34566 PyThreadState* __tstate = wxPyBeginAllowThreads();
34567 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34568 wxPyEndAllowThreads(__tstate);
34569 if (PyErr_Occurred()) SWIG_fail;
34570 }
34571 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34572 return resultobj;
34573 fail:
34574 return NULL;
34575 }
34576
34577
34578 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34579 PyObject *resultobj = 0;
34580 wxWindow *arg1 = (wxWindow *) 0 ;
34581 wxPoint *arg2 = 0 ;
34582 wxPoint result;
34583 void *argp1 = 0 ;
34584 int res1 = 0 ;
34585 wxPoint temp2 ;
34586 PyObject * obj0 = 0 ;
34587 PyObject * obj1 = 0 ;
34588 char * kwnames[] = {
34589 (char *) "self",(char *) "pt", NULL
34590 };
34591
34592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34594 if (!SWIG_IsOK(res1)) {
34595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34596 }
34597 arg1 = reinterpret_cast< wxWindow * >(argp1);
34598 {
34599 arg2 = &temp2;
34600 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34601 }
34602 {
34603 PyThreadState* __tstate = wxPyBeginAllowThreads();
34604 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34605 wxPyEndAllowThreads(__tstate);
34606 if (PyErr_Occurred()) SWIG_fail;
34607 }
34608 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34609 return resultobj;
34610 fail:
34611 return NULL;
34612 }
34613
34614
34615 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34616 PyObject *resultobj = 0;
34617 wxWindow *arg1 = (wxWindow *) 0 ;
34618 wxSize *arg2 = 0 ;
34619 wxSize result;
34620 void *argp1 = 0 ;
34621 int res1 = 0 ;
34622 wxSize temp2 ;
34623 PyObject * obj0 = 0 ;
34624 PyObject * obj1 = 0 ;
34625 char * kwnames[] = {
34626 (char *) "self",(char *) "sz", NULL
34627 };
34628
34629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34631 if (!SWIG_IsOK(res1)) {
34632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34633 }
34634 arg1 = reinterpret_cast< wxWindow * >(argp1);
34635 {
34636 arg2 = &temp2;
34637 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34638 }
34639 {
34640 PyThreadState* __tstate = wxPyBeginAllowThreads();
34641 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34642 wxPyEndAllowThreads(__tstate);
34643 if (PyErr_Occurred()) SWIG_fail;
34644 }
34645 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34646 return resultobj;
34647 fail:
34648 return NULL;
34649 }
34650
34651
34652 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34653 PyObject *resultobj = 0;
34654 wxWindow *arg1 = (wxWindow *) 0 ;
34655 wxPoint *arg2 = 0 ;
34656 wxPoint result;
34657 void *argp1 = 0 ;
34658 int res1 = 0 ;
34659 wxPoint temp2 ;
34660 PyObject * obj0 = 0 ;
34661 PyObject * obj1 = 0 ;
34662 char * kwnames[] = {
34663 (char *) "self",(char *) "pt", NULL
34664 };
34665
34666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34668 if (!SWIG_IsOK(res1)) {
34669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34670 }
34671 arg1 = reinterpret_cast< wxWindow * >(argp1);
34672 {
34673 arg2 = &temp2;
34674 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34675 }
34676 {
34677 PyThreadState* __tstate = wxPyBeginAllowThreads();
34678 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34679 wxPyEndAllowThreads(__tstate);
34680 if (PyErr_Occurred()) SWIG_fail;
34681 }
34682 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34683 return resultobj;
34684 fail:
34685 return NULL;
34686 }
34687
34688
34689 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34690 PyObject *resultobj = 0;
34691 wxWindow *arg1 = (wxWindow *) 0 ;
34692 wxSize *arg2 = 0 ;
34693 wxSize result;
34694 void *argp1 = 0 ;
34695 int res1 = 0 ;
34696 wxSize temp2 ;
34697 PyObject * obj0 = 0 ;
34698 PyObject * obj1 = 0 ;
34699 char * kwnames[] = {
34700 (char *) "self",(char *) "sz", NULL
34701 };
34702
34703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34705 if (!SWIG_IsOK(res1)) {
34706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34707 }
34708 arg1 = reinterpret_cast< wxWindow * >(argp1);
34709 {
34710 arg2 = &temp2;
34711 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34712 }
34713 {
34714 PyThreadState* __tstate = wxPyBeginAllowThreads();
34715 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34716 wxPyEndAllowThreads(__tstate);
34717 if (PyErr_Occurred()) SWIG_fail;
34718 }
34719 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34720 return resultobj;
34721 fail:
34722 return NULL;
34723 }
34724
34725
34726 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34727 PyObject *resultobj = 0;
34728 wxWindow *arg1 = (wxWindow *) 0 ;
34729 int arg2 ;
34730 int arg3 ;
34731 void *argp1 = 0 ;
34732 int res1 = 0 ;
34733 int val2 ;
34734 int ecode2 = 0 ;
34735 int val3 ;
34736 int ecode3 = 0 ;
34737 PyObject * obj0 = 0 ;
34738 PyObject * obj1 = 0 ;
34739 PyObject * obj2 = 0 ;
34740 char * kwnames[] = {
34741 (char *) "self",(char *) "x",(char *) "y", NULL
34742 };
34743
34744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34746 if (!SWIG_IsOK(res1)) {
34747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34748 }
34749 arg1 = reinterpret_cast< wxWindow * >(argp1);
34750 ecode2 = SWIG_AsVal_int(obj1, &val2);
34751 if (!SWIG_IsOK(ecode2)) {
34752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34753 }
34754 arg2 = static_cast< int >(val2);
34755 ecode3 = SWIG_AsVal_int(obj2, &val3);
34756 if (!SWIG_IsOK(ecode3)) {
34757 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34758 }
34759 arg3 = static_cast< int >(val3);
34760 {
34761 PyThreadState* __tstate = wxPyBeginAllowThreads();
34762 (arg1)->WarpPointer(arg2,arg3);
34763 wxPyEndAllowThreads(__tstate);
34764 if (PyErr_Occurred()) SWIG_fail;
34765 }
34766 resultobj = SWIG_Py_Void();
34767 return resultobj;
34768 fail:
34769 return NULL;
34770 }
34771
34772
34773 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34774 PyObject *resultobj = 0;
34775 wxWindow *arg1 = (wxWindow *) 0 ;
34776 void *argp1 = 0 ;
34777 int res1 = 0 ;
34778 PyObject *swig_obj[1] ;
34779
34780 if (!args) SWIG_fail;
34781 swig_obj[0] = args;
34782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34783 if (!SWIG_IsOK(res1)) {
34784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34785 }
34786 arg1 = reinterpret_cast< wxWindow * >(argp1);
34787 {
34788 PyThreadState* __tstate = wxPyBeginAllowThreads();
34789 (arg1)->CaptureMouse();
34790 wxPyEndAllowThreads(__tstate);
34791 if (PyErr_Occurred()) SWIG_fail;
34792 }
34793 resultobj = SWIG_Py_Void();
34794 return resultobj;
34795 fail:
34796 return NULL;
34797 }
34798
34799
34800 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34801 PyObject *resultobj = 0;
34802 wxWindow *arg1 = (wxWindow *) 0 ;
34803 void *argp1 = 0 ;
34804 int res1 = 0 ;
34805 PyObject *swig_obj[1] ;
34806
34807 if (!args) SWIG_fail;
34808 swig_obj[0] = args;
34809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34810 if (!SWIG_IsOK(res1)) {
34811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34812 }
34813 arg1 = reinterpret_cast< wxWindow * >(argp1);
34814 {
34815 PyThreadState* __tstate = wxPyBeginAllowThreads();
34816 (arg1)->ReleaseMouse();
34817 wxPyEndAllowThreads(__tstate);
34818 if (PyErr_Occurred()) SWIG_fail;
34819 }
34820 resultobj = SWIG_Py_Void();
34821 return resultobj;
34822 fail:
34823 return NULL;
34824 }
34825
34826
34827 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34828 PyObject *resultobj = 0;
34829 wxWindow *result = 0 ;
34830
34831 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34832 {
34833 if (!wxPyCheckForApp()) SWIG_fail;
34834 PyThreadState* __tstate = wxPyBeginAllowThreads();
34835 result = (wxWindow *)wxWindow::GetCapture();
34836 wxPyEndAllowThreads(__tstate);
34837 if (PyErr_Occurred()) SWIG_fail;
34838 }
34839 {
34840 resultobj = wxPyMake_wxObject(result, 0);
34841 }
34842 return resultobj;
34843 fail:
34844 return NULL;
34845 }
34846
34847
34848 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34849 PyObject *resultobj = 0;
34850 wxWindow *arg1 = (wxWindow *) 0 ;
34851 bool result;
34852 void *argp1 = 0 ;
34853 int res1 = 0 ;
34854 PyObject *swig_obj[1] ;
34855
34856 if (!args) SWIG_fail;
34857 swig_obj[0] = args;
34858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34859 if (!SWIG_IsOK(res1)) {
34860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34861 }
34862 arg1 = reinterpret_cast< wxWindow * >(argp1);
34863 {
34864 PyThreadState* __tstate = wxPyBeginAllowThreads();
34865 result = (bool)((wxWindow const *)arg1)->HasCapture();
34866 wxPyEndAllowThreads(__tstate);
34867 if (PyErr_Occurred()) SWIG_fail;
34868 }
34869 {
34870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34871 }
34872 return resultobj;
34873 fail:
34874 return NULL;
34875 }
34876
34877
34878 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34879 PyObject *resultobj = 0;
34880 wxWindow *arg1 = (wxWindow *) 0 ;
34881 bool arg2 = (bool) true ;
34882 wxRect *arg3 = (wxRect *) NULL ;
34883 void *argp1 = 0 ;
34884 int res1 = 0 ;
34885 bool val2 ;
34886 int ecode2 = 0 ;
34887 void *argp3 = 0 ;
34888 int res3 = 0 ;
34889 PyObject * obj0 = 0 ;
34890 PyObject * obj1 = 0 ;
34891 PyObject * obj2 = 0 ;
34892 char * kwnames[] = {
34893 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34894 };
34895
34896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34898 if (!SWIG_IsOK(res1)) {
34899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34900 }
34901 arg1 = reinterpret_cast< wxWindow * >(argp1);
34902 if (obj1) {
34903 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34904 if (!SWIG_IsOK(ecode2)) {
34905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34906 }
34907 arg2 = static_cast< bool >(val2);
34908 }
34909 if (obj2) {
34910 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34911 if (!SWIG_IsOK(res3)) {
34912 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34913 }
34914 arg3 = reinterpret_cast< wxRect * >(argp3);
34915 }
34916 {
34917 PyThreadState* __tstate = wxPyBeginAllowThreads();
34918 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34919 wxPyEndAllowThreads(__tstate);
34920 if (PyErr_Occurred()) SWIG_fail;
34921 }
34922 resultobj = SWIG_Py_Void();
34923 return resultobj;
34924 fail:
34925 return NULL;
34926 }
34927
34928
34929 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34930 PyObject *resultobj = 0;
34931 wxWindow *arg1 = (wxWindow *) 0 ;
34932 wxRect *arg2 = 0 ;
34933 bool arg3 = (bool) true ;
34934 void *argp1 = 0 ;
34935 int res1 = 0 ;
34936 wxRect temp2 ;
34937 bool val3 ;
34938 int ecode3 = 0 ;
34939 PyObject * obj0 = 0 ;
34940 PyObject * obj1 = 0 ;
34941 PyObject * obj2 = 0 ;
34942 char * kwnames[] = {
34943 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34944 };
34945
34946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34948 if (!SWIG_IsOK(res1)) {
34949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34950 }
34951 arg1 = reinterpret_cast< wxWindow * >(argp1);
34952 {
34953 arg2 = &temp2;
34954 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34955 }
34956 if (obj2) {
34957 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34958 if (!SWIG_IsOK(ecode3)) {
34959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34960 }
34961 arg3 = static_cast< bool >(val3);
34962 }
34963 {
34964 PyThreadState* __tstate = wxPyBeginAllowThreads();
34965 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34966 wxPyEndAllowThreads(__tstate);
34967 if (PyErr_Occurred()) SWIG_fail;
34968 }
34969 resultobj = SWIG_Py_Void();
34970 return resultobj;
34971 fail:
34972 return NULL;
34973 }
34974
34975
34976 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34977 PyObject *resultobj = 0;
34978 wxWindow *arg1 = (wxWindow *) 0 ;
34979 void *argp1 = 0 ;
34980 int res1 = 0 ;
34981 PyObject *swig_obj[1] ;
34982
34983 if (!args) SWIG_fail;
34984 swig_obj[0] = args;
34985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34986 if (!SWIG_IsOK(res1)) {
34987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34988 }
34989 arg1 = reinterpret_cast< wxWindow * >(argp1);
34990 {
34991 PyThreadState* __tstate = wxPyBeginAllowThreads();
34992 (arg1)->Update();
34993 wxPyEndAllowThreads(__tstate);
34994 if (PyErr_Occurred()) SWIG_fail;
34995 }
34996 resultobj = SWIG_Py_Void();
34997 return resultobj;
34998 fail:
34999 return NULL;
35000 }
35001
35002
35003 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35004 PyObject *resultobj = 0;
35005 wxWindow *arg1 = (wxWindow *) 0 ;
35006 void *argp1 = 0 ;
35007 int res1 = 0 ;
35008 PyObject *swig_obj[1] ;
35009
35010 if (!args) SWIG_fail;
35011 swig_obj[0] = args;
35012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35013 if (!SWIG_IsOK(res1)) {
35014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35015 }
35016 arg1 = reinterpret_cast< wxWindow * >(argp1);
35017 {
35018 PyThreadState* __tstate = wxPyBeginAllowThreads();
35019 (arg1)->ClearBackground();
35020 wxPyEndAllowThreads(__tstate);
35021 if (PyErr_Occurred()) SWIG_fail;
35022 }
35023 resultobj = SWIG_Py_Void();
35024 return resultobj;
35025 fail:
35026 return NULL;
35027 }
35028
35029
35030 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35031 PyObject *resultobj = 0;
35032 wxWindow *arg1 = (wxWindow *) 0 ;
35033 void *argp1 = 0 ;
35034 int res1 = 0 ;
35035 PyObject *swig_obj[1] ;
35036
35037 if (!args) SWIG_fail;
35038 swig_obj[0] = args;
35039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35040 if (!SWIG_IsOK(res1)) {
35041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35042 }
35043 arg1 = reinterpret_cast< wxWindow * >(argp1);
35044 {
35045 PyThreadState* __tstate = wxPyBeginAllowThreads();
35046 (arg1)->Freeze();
35047 wxPyEndAllowThreads(__tstate);
35048 if (PyErr_Occurred()) SWIG_fail;
35049 }
35050 resultobj = SWIG_Py_Void();
35051 return resultobj;
35052 fail:
35053 return NULL;
35054 }
35055
35056
35057 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35058 PyObject *resultobj = 0;
35059 wxWindow *arg1 = (wxWindow *) 0 ;
35060 bool result;
35061 void *argp1 = 0 ;
35062 int res1 = 0 ;
35063 PyObject *swig_obj[1] ;
35064
35065 if (!args) SWIG_fail;
35066 swig_obj[0] = args;
35067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35068 if (!SWIG_IsOK(res1)) {
35069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35070 }
35071 arg1 = reinterpret_cast< wxWindow * >(argp1);
35072 {
35073 PyThreadState* __tstate = wxPyBeginAllowThreads();
35074 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35075 wxPyEndAllowThreads(__tstate);
35076 if (PyErr_Occurred()) SWIG_fail;
35077 }
35078 {
35079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35080 }
35081 return resultobj;
35082 fail:
35083 return NULL;
35084 }
35085
35086
35087 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35088 PyObject *resultobj = 0;
35089 wxWindow *arg1 = (wxWindow *) 0 ;
35090 void *argp1 = 0 ;
35091 int res1 = 0 ;
35092 PyObject *swig_obj[1] ;
35093
35094 if (!args) SWIG_fail;
35095 swig_obj[0] = args;
35096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35097 if (!SWIG_IsOK(res1)) {
35098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35099 }
35100 arg1 = reinterpret_cast< wxWindow * >(argp1);
35101 {
35102 PyThreadState* __tstate = wxPyBeginAllowThreads();
35103 (arg1)->Thaw();
35104 wxPyEndAllowThreads(__tstate);
35105 if (PyErr_Occurred()) SWIG_fail;
35106 }
35107 resultobj = SWIG_Py_Void();
35108 return resultobj;
35109 fail:
35110 return NULL;
35111 }
35112
35113
35114 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35115 PyObject *resultobj = 0;
35116 wxWindow *arg1 = (wxWindow *) 0 ;
35117 wxDC *arg2 = 0 ;
35118 void *argp1 = 0 ;
35119 int res1 = 0 ;
35120 void *argp2 = 0 ;
35121 int res2 = 0 ;
35122 PyObject * obj0 = 0 ;
35123 PyObject * obj1 = 0 ;
35124 char * kwnames[] = {
35125 (char *) "self",(char *) "dc", NULL
35126 };
35127
35128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35130 if (!SWIG_IsOK(res1)) {
35131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35132 }
35133 arg1 = reinterpret_cast< wxWindow * >(argp1);
35134 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35135 if (!SWIG_IsOK(res2)) {
35136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35137 }
35138 if (!argp2) {
35139 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35140 }
35141 arg2 = reinterpret_cast< wxDC * >(argp2);
35142 {
35143 PyThreadState* __tstate = wxPyBeginAllowThreads();
35144 (arg1)->PrepareDC(*arg2);
35145 wxPyEndAllowThreads(__tstate);
35146 if (PyErr_Occurred()) SWIG_fail;
35147 }
35148 resultobj = SWIG_Py_Void();
35149 return resultobj;
35150 fail:
35151 return NULL;
35152 }
35153
35154
35155 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35156 PyObject *resultobj = 0;
35157 wxWindow *arg1 = (wxWindow *) 0 ;
35158 wxRegion *result = 0 ;
35159 void *argp1 = 0 ;
35160 int res1 = 0 ;
35161 PyObject *swig_obj[1] ;
35162
35163 if (!args) SWIG_fail;
35164 swig_obj[0] = args;
35165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35166 if (!SWIG_IsOK(res1)) {
35167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35168 }
35169 arg1 = reinterpret_cast< wxWindow * >(argp1);
35170 {
35171 PyThreadState* __tstate = wxPyBeginAllowThreads();
35172 {
35173 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35174 result = (wxRegion *) &_result_ref;
35175 }
35176 wxPyEndAllowThreads(__tstate);
35177 if (PyErr_Occurred()) SWIG_fail;
35178 }
35179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35180 return resultobj;
35181 fail:
35182 return NULL;
35183 }
35184
35185
35186 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35187 PyObject *resultobj = 0;
35188 wxWindow *arg1 = (wxWindow *) 0 ;
35189 wxRect result;
35190 void *argp1 = 0 ;
35191 int res1 = 0 ;
35192 PyObject *swig_obj[1] ;
35193
35194 if (!args) SWIG_fail;
35195 swig_obj[0] = args;
35196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35197 if (!SWIG_IsOK(res1)) {
35198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35199 }
35200 arg1 = reinterpret_cast< wxWindow * >(argp1);
35201 {
35202 PyThreadState* __tstate = wxPyBeginAllowThreads();
35203 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35204 wxPyEndAllowThreads(__tstate);
35205 if (PyErr_Occurred()) SWIG_fail;
35206 }
35207 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35208 return resultobj;
35209 fail:
35210 return NULL;
35211 }
35212
35213
35214 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35215 PyObject *resultobj = 0;
35216 wxWindow *arg1 = (wxWindow *) 0 ;
35217 int arg2 ;
35218 int arg3 ;
35219 int arg4 = (int) 1 ;
35220 int arg5 = (int) 1 ;
35221 bool result;
35222 void *argp1 = 0 ;
35223 int res1 = 0 ;
35224 int val2 ;
35225 int ecode2 = 0 ;
35226 int val3 ;
35227 int ecode3 = 0 ;
35228 int val4 ;
35229 int ecode4 = 0 ;
35230 int val5 ;
35231 int ecode5 = 0 ;
35232 PyObject * obj0 = 0 ;
35233 PyObject * obj1 = 0 ;
35234 PyObject * obj2 = 0 ;
35235 PyObject * obj3 = 0 ;
35236 PyObject * obj4 = 0 ;
35237 char * kwnames[] = {
35238 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35239 };
35240
35241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35243 if (!SWIG_IsOK(res1)) {
35244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35245 }
35246 arg1 = reinterpret_cast< wxWindow * >(argp1);
35247 ecode2 = SWIG_AsVal_int(obj1, &val2);
35248 if (!SWIG_IsOK(ecode2)) {
35249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35250 }
35251 arg2 = static_cast< int >(val2);
35252 ecode3 = SWIG_AsVal_int(obj2, &val3);
35253 if (!SWIG_IsOK(ecode3)) {
35254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35255 }
35256 arg3 = static_cast< int >(val3);
35257 if (obj3) {
35258 ecode4 = SWIG_AsVal_int(obj3, &val4);
35259 if (!SWIG_IsOK(ecode4)) {
35260 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35261 }
35262 arg4 = static_cast< int >(val4);
35263 }
35264 if (obj4) {
35265 ecode5 = SWIG_AsVal_int(obj4, &val5);
35266 if (!SWIG_IsOK(ecode5)) {
35267 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35268 }
35269 arg5 = static_cast< int >(val5);
35270 }
35271 {
35272 PyThreadState* __tstate = wxPyBeginAllowThreads();
35273 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
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_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35287 PyObject *resultobj = 0;
35288 wxWindow *arg1 = (wxWindow *) 0 ;
35289 wxPoint *arg2 = 0 ;
35290 bool result;
35291 void *argp1 = 0 ;
35292 int res1 = 0 ;
35293 wxPoint temp2 ;
35294 PyObject * obj0 = 0 ;
35295 PyObject * obj1 = 0 ;
35296 char * kwnames[] = {
35297 (char *) "self",(char *) "pt", NULL
35298 };
35299
35300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",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_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35304 }
35305 arg1 = reinterpret_cast< wxWindow * >(argp1);
35306 {
35307 arg2 = &temp2;
35308 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35309 }
35310 {
35311 PyThreadState* __tstate = wxPyBeginAllowThreads();
35312 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35313 wxPyEndAllowThreads(__tstate);
35314 if (PyErr_Occurred()) SWIG_fail;
35315 }
35316 {
35317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35318 }
35319 return resultobj;
35320 fail:
35321 return NULL;
35322 }
35323
35324
35325 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35326 PyObject *resultobj = 0;
35327 wxWindow *arg1 = (wxWindow *) 0 ;
35328 wxRect *arg2 = 0 ;
35329 bool result;
35330 void *argp1 = 0 ;
35331 int res1 = 0 ;
35332 wxRect temp2 ;
35333 PyObject * obj0 = 0 ;
35334 PyObject * obj1 = 0 ;
35335 char * kwnames[] = {
35336 (char *) "self",(char *) "rect", NULL
35337 };
35338
35339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35341 if (!SWIG_IsOK(res1)) {
35342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35343 }
35344 arg1 = reinterpret_cast< wxWindow * >(argp1);
35345 {
35346 arg2 = &temp2;
35347 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35348 }
35349 {
35350 PyThreadState* __tstate = wxPyBeginAllowThreads();
35351 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35352 wxPyEndAllowThreads(__tstate);
35353 if (PyErr_Occurred()) SWIG_fail;
35354 }
35355 {
35356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35357 }
35358 return resultobj;
35359 fail:
35360 return NULL;
35361 }
35362
35363
35364 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35365 PyObject *resultobj = 0;
35366 wxWindow *arg1 = (wxWindow *) 0 ;
35367 SwigValueWrapper<wxVisualAttributes > result;
35368 void *argp1 = 0 ;
35369 int res1 = 0 ;
35370 PyObject *swig_obj[1] ;
35371
35372 if (!args) SWIG_fail;
35373 swig_obj[0] = args;
35374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35375 if (!SWIG_IsOK(res1)) {
35376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35377 }
35378 arg1 = reinterpret_cast< wxWindow * >(argp1);
35379 {
35380 PyThreadState* __tstate = wxPyBeginAllowThreads();
35381 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35382 wxPyEndAllowThreads(__tstate);
35383 if (PyErr_Occurred()) SWIG_fail;
35384 }
35385 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35386 return resultobj;
35387 fail:
35388 return NULL;
35389 }
35390
35391
35392 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35393 PyObject *resultobj = 0;
35394 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35395 SwigValueWrapper<wxVisualAttributes > result;
35396 int val1 ;
35397 int ecode1 = 0 ;
35398 PyObject * obj0 = 0 ;
35399 char * kwnames[] = {
35400 (char *) "variant", NULL
35401 };
35402
35403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
35404 if (obj0) {
35405 ecode1 = SWIG_AsVal_int(obj0, &val1);
35406 if (!SWIG_IsOK(ecode1)) {
35407 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
35408 }
35409 arg1 = static_cast< wxWindowVariant >(val1);
35410 }
35411 {
35412 if (!wxPyCheckForApp()) SWIG_fail;
35413 PyThreadState* __tstate = wxPyBeginAllowThreads();
35414 result = wxWindow::GetClassDefaultAttributes(arg1);
35415 wxPyEndAllowThreads(__tstate);
35416 if (PyErr_Occurred()) SWIG_fail;
35417 }
35418 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35419 return resultobj;
35420 fail:
35421 return NULL;
35422 }
35423
35424
35425 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35426 PyObject *resultobj = 0;
35427 wxWindow *arg1 = (wxWindow *) 0 ;
35428 wxColour *arg2 = 0 ;
35429 bool result;
35430 void *argp1 = 0 ;
35431 int res1 = 0 ;
35432 wxColour temp2 ;
35433 PyObject * obj0 = 0 ;
35434 PyObject * obj1 = 0 ;
35435 char * kwnames[] = {
35436 (char *) "self",(char *) "colour", NULL
35437 };
35438
35439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35441 if (!SWIG_IsOK(res1)) {
35442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35443 }
35444 arg1 = reinterpret_cast< wxWindow * >(argp1);
35445 {
35446 arg2 = &temp2;
35447 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35448 }
35449 {
35450 PyThreadState* __tstate = wxPyBeginAllowThreads();
35451 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35452 wxPyEndAllowThreads(__tstate);
35453 if (PyErr_Occurred()) SWIG_fail;
35454 }
35455 {
35456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35457 }
35458 return resultobj;
35459 fail:
35460 return NULL;
35461 }
35462
35463
35464 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35465 PyObject *resultobj = 0;
35466 wxWindow *arg1 = (wxWindow *) 0 ;
35467 wxColour *arg2 = 0 ;
35468 void *argp1 = 0 ;
35469 int res1 = 0 ;
35470 wxColour temp2 ;
35471 PyObject * obj0 = 0 ;
35472 PyObject * obj1 = 0 ;
35473 char * kwnames[] = {
35474 (char *) "self",(char *) "colour", NULL
35475 };
35476
35477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35479 if (!SWIG_IsOK(res1)) {
35480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35481 }
35482 arg1 = reinterpret_cast< wxWindow * >(argp1);
35483 {
35484 arg2 = &temp2;
35485 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35486 }
35487 {
35488 PyThreadState* __tstate = wxPyBeginAllowThreads();
35489 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35490 wxPyEndAllowThreads(__tstate);
35491 if (PyErr_Occurred()) SWIG_fail;
35492 }
35493 resultobj = SWIG_Py_Void();
35494 return resultobj;
35495 fail:
35496 return NULL;
35497 }
35498
35499
35500 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35501 PyObject *resultobj = 0;
35502 wxWindow *arg1 = (wxWindow *) 0 ;
35503 wxColour *arg2 = 0 ;
35504 bool result;
35505 void *argp1 = 0 ;
35506 int res1 = 0 ;
35507 wxColour temp2 ;
35508 PyObject * obj0 = 0 ;
35509 PyObject * obj1 = 0 ;
35510 char * kwnames[] = {
35511 (char *) "self",(char *) "colour", NULL
35512 };
35513
35514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35516 if (!SWIG_IsOK(res1)) {
35517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35518 }
35519 arg1 = reinterpret_cast< wxWindow * >(argp1);
35520 {
35521 arg2 = &temp2;
35522 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35523 }
35524 {
35525 PyThreadState* __tstate = wxPyBeginAllowThreads();
35526 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35527 wxPyEndAllowThreads(__tstate);
35528 if (PyErr_Occurred()) SWIG_fail;
35529 }
35530 {
35531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35532 }
35533 return resultobj;
35534 fail:
35535 return NULL;
35536 }
35537
35538
35539 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35540 PyObject *resultobj = 0;
35541 wxWindow *arg1 = (wxWindow *) 0 ;
35542 wxColour *arg2 = 0 ;
35543 void *argp1 = 0 ;
35544 int res1 = 0 ;
35545 wxColour temp2 ;
35546 PyObject * obj0 = 0 ;
35547 PyObject * obj1 = 0 ;
35548 char * kwnames[] = {
35549 (char *) "self",(char *) "colour", NULL
35550 };
35551
35552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35554 if (!SWIG_IsOK(res1)) {
35555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35556 }
35557 arg1 = reinterpret_cast< wxWindow * >(argp1);
35558 {
35559 arg2 = &temp2;
35560 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35561 }
35562 {
35563 PyThreadState* __tstate = wxPyBeginAllowThreads();
35564 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35565 wxPyEndAllowThreads(__tstate);
35566 if (PyErr_Occurred()) SWIG_fail;
35567 }
35568 resultobj = SWIG_Py_Void();
35569 return resultobj;
35570 fail:
35571 return NULL;
35572 }
35573
35574
35575 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35576 PyObject *resultobj = 0;
35577 wxWindow *arg1 = (wxWindow *) 0 ;
35578 wxColour result;
35579 void *argp1 = 0 ;
35580 int res1 = 0 ;
35581 PyObject *swig_obj[1] ;
35582
35583 if (!args) SWIG_fail;
35584 swig_obj[0] = args;
35585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35586 if (!SWIG_IsOK(res1)) {
35587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35588 }
35589 arg1 = reinterpret_cast< wxWindow * >(argp1);
35590 {
35591 PyThreadState* __tstate = wxPyBeginAllowThreads();
35592 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35593 wxPyEndAllowThreads(__tstate);
35594 if (PyErr_Occurred()) SWIG_fail;
35595 }
35596 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35597 return resultobj;
35598 fail:
35599 return NULL;
35600 }
35601
35602
35603 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35604 PyObject *resultobj = 0;
35605 wxWindow *arg1 = (wxWindow *) 0 ;
35606 wxColour result;
35607 void *argp1 = 0 ;
35608 int res1 = 0 ;
35609 PyObject *swig_obj[1] ;
35610
35611 if (!args) SWIG_fail;
35612 swig_obj[0] = args;
35613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35614 if (!SWIG_IsOK(res1)) {
35615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35616 }
35617 arg1 = reinterpret_cast< wxWindow * >(argp1);
35618 {
35619 PyThreadState* __tstate = wxPyBeginAllowThreads();
35620 result = ((wxWindow const *)arg1)->GetForegroundColour();
35621 wxPyEndAllowThreads(__tstate);
35622 if (PyErr_Occurred()) SWIG_fail;
35623 }
35624 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35625 return resultobj;
35626 fail:
35627 return NULL;
35628 }
35629
35630
35631 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35632 PyObject *resultobj = 0;
35633 wxWindow *arg1 = (wxWindow *) 0 ;
35634 bool result;
35635 void *argp1 = 0 ;
35636 int res1 = 0 ;
35637 PyObject *swig_obj[1] ;
35638
35639 if (!args) SWIG_fail;
35640 swig_obj[0] = args;
35641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35642 if (!SWIG_IsOK(res1)) {
35643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35644 }
35645 arg1 = reinterpret_cast< wxWindow * >(argp1);
35646 {
35647 PyThreadState* __tstate = wxPyBeginAllowThreads();
35648 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35649 wxPyEndAllowThreads(__tstate);
35650 if (PyErr_Occurred()) SWIG_fail;
35651 }
35652 {
35653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35654 }
35655 return resultobj;
35656 fail:
35657 return NULL;
35658 }
35659
35660
35661 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35662 PyObject *resultobj = 0;
35663 wxWindow *arg1 = (wxWindow *) 0 ;
35664 bool result;
35665 void *argp1 = 0 ;
35666 int res1 = 0 ;
35667 PyObject *swig_obj[1] ;
35668
35669 if (!args) SWIG_fail;
35670 swig_obj[0] = args;
35671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35672 if (!SWIG_IsOK(res1)) {
35673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35674 }
35675 arg1 = reinterpret_cast< wxWindow * >(argp1);
35676 {
35677 PyThreadState* __tstate = wxPyBeginAllowThreads();
35678 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35679 wxPyEndAllowThreads(__tstate);
35680 if (PyErr_Occurred()) SWIG_fail;
35681 }
35682 {
35683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35684 }
35685 return resultobj;
35686 fail:
35687 return NULL;
35688 }
35689
35690
35691 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35692 PyObject *resultobj = 0;
35693 wxWindow *arg1 = (wxWindow *) 0 ;
35694 wxBackgroundStyle arg2 ;
35695 bool result;
35696 void *argp1 = 0 ;
35697 int res1 = 0 ;
35698 int val2 ;
35699 int ecode2 = 0 ;
35700 PyObject * obj0 = 0 ;
35701 PyObject * obj1 = 0 ;
35702 char * kwnames[] = {
35703 (char *) "self",(char *) "style", NULL
35704 };
35705
35706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35708 if (!SWIG_IsOK(res1)) {
35709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35710 }
35711 arg1 = reinterpret_cast< wxWindow * >(argp1);
35712 ecode2 = SWIG_AsVal_int(obj1, &val2);
35713 if (!SWIG_IsOK(ecode2)) {
35714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35715 }
35716 arg2 = static_cast< wxBackgroundStyle >(val2);
35717 {
35718 PyThreadState* __tstate = wxPyBeginAllowThreads();
35719 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35720 wxPyEndAllowThreads(__tstate);
35721 if (PyErr_Occurred()) SWIG_fail;
35722 }
35723 {
35724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35725 }
35726 return resultobj;
35727 fail:
35728 return NULL;
35729 }
35730
35731
35732 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35733 PyObject *resultobj = 0;
35734 wxWindow *arg1 = (wxWindow *) 0 ;
35735 wxBackgroundStyle result;
35736 void *argp1 = 0 ;
35737 int res1 = 0 ;
35738 PyObject *swig_obj[1] ;
35739
35740 if (!args) SWIG_fail;
35741 swig_obj[0] = args;
35742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35743 if (!SWIG_IsOK(res1)) {
35744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35745 }
35746 arg1 = reinterpret_cast< wxWindow * >(argp1);
35747 {
35748 PyThreadState* __tstate = wxPyBeginAllowThreads();
35749 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35750 wxPyEndAllowThreads(__tstate);
35751 if (PyErr_Occurred()) SWIG_fail;
35752 }
35753 resultobj = SWIG_From_int(static_cast< int >(result));
35754 return resultobj;
35755 fail:
35756 return NULL;
35757 }
35758
35759
35760 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35761 PyObject *resultobj = 0;
35762 wxWindow *arg1 = (wxWindow *) 0 ;
35763 bool result;
35764 void *argp1 = 0 ;
35765 int res1 = 0 ;
35766 PyObject *swig_obj[1] ;
35767
35768 if (!args) SWIG_fail;
35769 swig_obj[0] = args;
35770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35771 if (!SWIG_IsOK(res1)) {
35772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35773 }
35774 arg1 = reinterpret_cast< wxWindow * >(argp1);
35775 {
35776 PyThreadState* __tstate = wxPyBeginAllowThreads();
35777 result = (bool)(arg1)->HasTransparentBackground();
35778 wxPyEndAllowThreads(__tstate);
35779 if (PyErr_Occurred()) SWIG_fail;
35780 }
35781 {
35782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35783 }
35784 return resultobj;
35785 fail:
35786 return NULL;
35787 }
35788
35789
35790 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35791 PyObject *resultobj = 0;
35792 wxWindow *arg1 = (wxWindow *) 0 ;
35793 wxCursor *arg2 = 0 ;
35794 bool result;
35795 void *argp1 = 0 ;
35796 int res1 = 0 ;
35797 void *argp2 = 0 ;
35798 int res2 = 0 ;
35799 PyObject * obj0 = 0 ;
35800 PyObject * obj1 = 0 ;
35801 char * kwnames[] = {
35802 (char *) "self",(char *) "cursor", NULL
35803 };
35804
35805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35807 if (!SWIG_IsOK(res1)) {
35808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35809 }
35810 arg1 = reinterpret_cast< wxWindow * >(argp1);
35811 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35812 if (!SWIG_IsOK(res2)) {
35813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35814 }
35815 if (!argp2) {
35816 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35817 }
35818 arg2 = reinterpret_cast< wxCursor * >(argp2);
35819 {
35820 PyThreadState* __tstate = wxPyBeginAllowThreads();
35821 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35822 wxPyEndAllowThreads(__tstate);
35823 if (PyErr_Occurred()) SWIG_fail;
35824 }
35825 {
35826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35827 }
35828 return resultobj;
35829 fail:
35830 return NULL;
35831 }
35832
35833
35834 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35835 PyObject *resultobj = 0;
35836 wxWindow *arg1 = (wxWindow *) 0 ;
35837 wxCursor result;
35838 void *argp1 = 0 ;
35839 int res1 = 0 ;
35840 PyObject *swig_obj[1] ;
35841
35842 if (!args) SWIG_fail;
35843 swig_obj[0] = args;
35844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35845 if (!SWIG_IsOK(res1)) {
35846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35847 }
35848 arg1 = reinterpret_cast< wxWindow * >(argp1);
35849 {
35850 PyThreadState* __tstate = wxPyBeginAllowThreads();
35851 result = (arg1)->GetCursor();
35852 wxPyEndAllowThreads(__tstate);
35853 if (PyErr_Occurred()) SWIG_fail;
35854 }
35855 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35856 return resultobj;
35857 fail:
35858 return NULL;
35859 }
35860
35861
35862 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35863 PyObject *resultobj = 0;
35864 wxWindow *arg1 = (wxWindow *) 0 ;
35865 wxFont *arg2 = 0 ;
35866 bool result;
35867 void *argp1 = 0 ;
35868 int res1 = 0 ;
35869 void *argp2 = 0 ;
35870 int res2 = 0 ;
35871 PyObject * obj0 = 0 ;
35872 PyObject * obj1 = 0 ;
35873 char * kwnames[] = {
35874 (char *) "self",(char *) "font", NULL
35875 };
35876
35877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35879 if (!SWIG_IsOK(res1)) {
35880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35881 }
35882 arg1 = reinterpret_cast< wxWindow * >(argp1);
35883 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35884 if (!SWIG_IsOK(res2)) {
35885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35886 }
35887 if (!argp2) {
35888 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35889 }
35890 arg2 = reinterpret_cast< wxFont * >(argp2);
35891 {
35892 PyThreadState* __tstate = wxPyBeginAllowThreads();
35893 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35894 wxPyEndAllowThreads(__tstate);
35895 if (PyErr_Occurred()) SWIG_fail;
35896 }
35897 {
35898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35899 }
35900 return resultobj;
35901 fail:
35902 return NULL;
35903 }
35904
35905
35906 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35907 PyObject *resultobj = 0;
35908 wxWindow *arg1 = (wxWindow *) 0 ;
35909 wxFont *arg2 = 0 ;
35910 void *argp1 = 0 ;
35911 int res1 = 0 ;
35912 void *argp2 = 0 ;
35913 int res2 = 0 ;
35914 PyObject * obj0 = 0 ;
35915 PyObject * obj1 = 0 ;
35916 char * kwnames[] = {
35917 (char *) "self",(char *) "font", NULL
35918 };
35919
35920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35922 if (!SWIG_IsOK(res1)) {
35923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35924 }
35925 arg1 = reinterpret_cast< wxWindow * >(argp1);
35926 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35927 if (!SWIG_IsOK(res2)) {
35928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35929 }
35930 if (!argp2) {
35931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35932 }
35933 arg2 = reinterpret_cast< wxFont * >(argp2);
35934 {
35935 PyThreadState* __tstate = wxPyBeginAllowThreads();
35936 (arg1)->SetOwnFont((wxFont const &)*arg2);
35937 wxPyEndAllowThreads(__tstate);
35938 if (PyErr_Occurred()) SWIG_fail;
35939 }
35940 resultobj = SWIG_Py_Void();
35941 return resultobj;
35942 fail:
35943 return NULL;
35944 }
35945
35946
35947 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35948 PyObject *resultobj = 0;
35949 wxWindow *arg1 = (wxWindow *) 0 ;
35950 wxFont result;
35951 void *argp1 = 0 ;
35952 int res1 = 0 ;
35953 PyObject *swig_obj[1] ;
35954
35955 if (!args) SWIG_fail;
35956 swig_obj[0] = args;
35957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35958 if (!SWIG_IsOK(res1)) {
35959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35960 }
35961 arg1 = reinterpret_cast< wxWindow * >(argp1);
35962 {
35963 PyThreadState* __tstate = wxPyBeginAllowThreads();
35964 result = (arg1)->GetFont();
35965 wxPyEndAllowThreads(__tstate);
35966 if (PyErr_Occurred()) SWIG_fail;
35967 }
35968 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35969 return resultobj;
35970 fail:
35971 return NULL;
35972 }
35973
35974
35975 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35976 PyObject *resultobj = 0;
35977 wxWindow *arg1 = (wxWindow *) 0 ;
35978 wxCaret *arg2 = (wxCaret *) 0 ;
35979 void *argp1 = 0 ;
35980 int res1 = 0 ;
35981 int res2 = 0 ;
35982 PyObject * obj0 = 0 ;
35983 PyObject * obj1 = 0 ;
35984 char * kwnames[] = {
35985 (char *) "self",(char *) "caret", NULL
35986 };
35987
35988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35990 if (!SWIG_IsOK(res1)) {
35991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35992 }
35993 arg1 = reinterpret_cast< wxWindow * >(argp1);
35994 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35995 if (!SWIG_IsOK(res2)) {
35996 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35997 }
35998 {
35999 PyThreadState* __tstate = wxPyBeginAllowThreads();
36000 (arg1)->SetCaret(arg2);
36001 wxPyEndAllowThreads(__tstate);
36002 if (PyErr_Occurred()) SWIG_fail;
36003 }
36004 resultobj = SWIG_Py_Void();
36005 return resultobj;
36006 fail:
36007 return NULL;
36008 }
36009
36010
36011 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36012 PyObject *resultobj = 0;
36013 wxWindow *arg1 = (wxWindow *) 0 ;
36014 wxCaret *result = 0 ;
36015 void *argp1 = 0 ;
36016 int res1 = 0 ;
36017 PyObject *swig_obj[1] ;
36018
36019 if (!args) SWIG_fail;
36020 swig_obj[0] = args;
36021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36022 if (!SWIG_IsOK(res1)) {
36023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36024 }
36025 arg1 = reinterpret_cast< wxWindow * >(argp1);
36026 {
36027 PyThreadState* __tstate = wxPyBeginAllowThreads();
36028 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36029 wxPyEndAllowThreads(__tstate);
36030 if (PyErr_Occurred()) SWIG_fail;
36031 }
36032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36033 return resultobj;
36034 fail:
36035 return NULL;
36036 }
36037
36038
36039 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36040 PyObject *resultobj = 0;
36041 wxWindow *arg1 = (wxWindow *) 0 ;
36042 int result;
36043 void *argp1 = 0 ;
36044 int res1 = 0 ;
36045 PyObject *swig_obj[1] ;
36046
36047 if (!args) SWIG_fail;
36048 swig_obj[0] = args;
36049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36050 if (!SWIG_IsOK(res1)) {
36051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36052 }
36053 arg1 = reinterpret_cast< wxWindow * >(argp1);
36054 {
36055 PyThreadState* __tstate = wxPyBeginAllowThreads();
36056 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36057 wxPyEndAllowThreads(__tstate);
36058 if (PyErr_Occurred()) SWIG_fail;
36059 }
36060 resultobj = SWIG_From_int(static_cast< int >(result));
36061 return resultobj;
36062 fail:
36063 return NULL;
36064 }
36065
36066
36067 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36068 PyObject *resultobj = 0;
36069 wxWindow *arg1 = (wxWindow *) 0 ;
36070 int result;
36071 void *argp1 = 0 ;
36072 int res1 = 0 ;
36073 PyObject *swig_obj[1] ;
36074
36075 if (!args) SWIG_fail;
36076 swig_obj[0] = args;
36077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36078 if (!SWIG_IsOK(res1)) {
36079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36080 }
36081 arg1 = reinterpret_cast< wxWindow * >(argp1);
36082 {
36083 PyThreadState* __tstate = wxPyBeginAllowThreads();
36084 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36085 wxPyEndAllowThreads(__tstate);
36086 if (PyErr_Occurred()) SWIG_fail;
36087 }
36088 resultobj = SWIG_From_int(static_cast< int >(result));
36089 return resultobj;
36090 fail:
36091 return NULL;
36092 }
36093
36094
36095 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36096 PyObject *resultobj = 0;
36097 wxWindow *arg1 = (wxWindow *) 0 ;
36098 wxString *arg2 = 0 ;
36099 int *arg3 = (int *) 0 ;
36100 int *arg4 = (int *) 0 ;
36101 void *argp1 = 0 ;
36102 int res1 = 0 ;
36103 bool temp2 = false ;
36104 int temp3 ;
36105 int res3 = SWIG_TMPOBJ ;
36106 int temp4 ;
36107 int res4 = SWIG_TMPOBJ ;
36108 PyObject * obj0 = 0 ;
36109 PyObject * obj1 = 0 ;
36110 char * kwnames[] = {
36111 (char *) "self",(char *) "string", NULL
36112 };
36113
36114 arg3 = &temp3;
36115 arg4 = &temp4;
36116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36118 if (!SWIG_IsOK(res1)) {
36119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36120 }
36121 arg1 = reinterpret_cast< wxWindow * >(argp1);
36122 {
36123 arg2 = wxString_in_helper(obj1);
36124 if (arg2 == NULL) SWIG_fail;
36125 temp2 = true;
36126 }
36127 {
36128 PyThreadState* __tstate = wxPyBeginAllowThreads();
36129 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36130 wxPyEndAllowThreads(__tstate);
36131 if (PyErr_Occurred()) SWIG_fail;
36132 }
36133 resultobj = SWIG_Py_Void();
36134 if (SWIG_IsTmpObj(res3)) {
36135 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36136 } else {
36137 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36139 }
36140 if (SWIG_IsTmpObj(res4)) {
36141 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36142 } else {
36143 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36145 }
36146 {
36147 if (temp2)
36148 delete arg2;
36149 }
36150 return resultobj;
36151 fail:
36152 {
36153 if (temp2)
36154 delete arg2;
36155 }
36156 return NULL;
36157 }
36158
36159
36160 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36161 PyObject *resultobj = 0;
36162 wxWindow *arg1 = (wxWindow *) 0 ;
36163 wxString *arg2 = 0 ;
36164 int *arg3 = (int *) 0 ;
36165 int *arg4 = (int *) 0 ;
36166 int *arg5 = (int *) 0 ;
36167 int *arg6 = (int *) 0 ;
36168 wxFont *arg7 = (wxFont *) NULL ;
36169 void *argp1 = 0 ;
36170 int res1 = 0 ;
36171 bool temp2 = false ;
36172 int temp3 ;
36173 int res3 = SWIG_TMPOBJ ;
36174 int temp4 ;
36175 int res4 = SWIG_TMPOBJ ;
36176 int temp5 ;
36177 int res5 = SWIG_TMPOBJ ;
36178 int temp6 ;
36179 int res6 = SWIG_TMPOBJ ;
36180 void *argp7 = 0 ;
36181 int res7 = 0 ;
36182 PyObject * obj0 = 0 ;
36183 PyObject * obj1 = 0 ;
36184 PyObject * obj2 = 0 ;
36185 char * kwnames[] = {
36186 (char *) "self",(char *) "string",(char *) "font", NULL
36187 };
36188
36189 arg3 = &temp3;
36190 arg4 = &temp4;
36191 arg5 = &temp5;
36192 arg6 = &temp6;
36193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36195 if (!SWIG_IsOK(res1)) {
36196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36197 }
36198 arg1 = reinterpret_cast< wxWindow * >(argp1);
36199 {
36200 arg2 = wxString_in_helper(obj1);
36201 if (arg2 == NULL) SWIG_fail;
36202 temp2 = true;
36203 }
36204 if (obj2) {
36205 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36206 if (!SWIG_IsOK(res7)) {
36207 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36208 }
36209 arg7 = reinterpret_cast< wxFont * >(argp7);
36210 }
36211 {
36212 PyThreadState* __tstate = wxPyBeginAllowThreads();
36213 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36214 wxPyEndAllowThreads(__tstate);
36215 if (PyErr_Occurred()) SWIG_fail;
36216 }
36217 resultobj = SWIG_Py_Void();
36218 if (SWIG_IsTmpObj(res3)) {
36219 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36220 } else {
36221 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36222 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36223 }
36224 if (SWIG_IsTmpObj(res4)) {
36225 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36226 } else {
36227 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36229 }
36230 if (SWIG_IsTmpObj(res5)) {
36231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36232 } else {
36233 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36235 }
36236 if (SWIG_IsTmpObj(res6)) {
36237 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36238 } else {
36239 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36240 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36241 }
36242 {
36243 if (temp2)
36244 delete arg2;
36245 }
36246 return resultobj;
36247 fail:
36248 {
36249 if (temp2)
36250 delete arg2;
36251 }
36252 return NULL;
36253 }
36254
36255
36256 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36257 PyObject *resultobj = 0;
36258 wxWindow *arg1 = (wxWindow *) 0 ;
36259 int *arg2 = (int *) 0 ;
36260 int *arg3 = (int *) 0 ;
36261 void *argp1 = 0 ;
36262 int res1 = 0 ;
36263 int temp2 ;
36264 int res2 = 0 ;
36265 int temp3 ;
36266 int res3 = 0 ;
36267 PyObject * obj0 = 0 ;
36268 PyObject * obj1 = 0 ;
36269 PyObject * obj2 = 0 ;
36270 char * kwnames[] = {
36271 (char *) "self",(char *) "x",(char *) "y", NULL
36272 };
36273
36274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36276 if (!SWIG_IsOK(res1)) {
36277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36278 }
36279 arg1 = reinterpret_cast< wxWindow * >(argp1);
36280 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36281 int val;
36282 int ecode = SWIG_AsVal_int(obj1, &val);
36283 if (!SWIG_IsOK(ecode)) {
36284 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36285 }
36286 temp2 = static_cast< int >(val);
36287 arg2 = &temp2;
36288 res2 = SWIG_AddTmpMask(ecode);
36289 }
36290 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36291 int val;
36292 int ecode = SWIG_AsVal_int(obj2, &val);
36293 if (!SWIG_IsOK(ecode)) {
36294 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36295 }
36296 temp3 = static_cast< int >(val);
36297 arg3 = &temp3;
36298 res3 = SWIG_AddTmpMask(ecode);
36299 }
36300 {
36301 PyThreadState* __tstate = wxPyBeginAllowThreads();
36302 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36303 wxPyEndAllowThreads(__tstate);
36304 if (PyErr_Occurred()) SWIG_fail;
36305 }
36306 resultobj = SWIG_Py_Void();
36307 if (SWIG_IsTmpObj(res2)) {
36308 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36309 } else {
36310 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36311 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36312 }
36313 if (SWIG_IsTmpObj(res3)) {
36314 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36315 } else {
36316 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36317 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36318 }
36319 return resultobj;
36320 fail:
36321 return NULL;
36322 }
36323
36324
36325 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36326 PyObject *resultobj = 0;
36327 wxWindow *arg1 = (wxWindow *) 0 ;
36328 int *arg2 = (int *) 0 ;
36329 int *arg3 = (int *) 0 ;
36330 void *argp1 = 0 ;
36331 int res1 = 0 ;
36332 int temp2 ;
36333 int res2 = 0 ;
36334 int temp3 ;
36335 int res3 = 0 ;
36336 PyObject * obj0 = 0 ;
36337 PyObject * obj1 = 0 ;
36338 PyObject * obj2 = 0 ;
36339 char * kwnames[] = {
36340 (char *) "self",(char *) "x",(char *) "y", NULL
36341 };
36342
36343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36345 if (!SWIG_IsOK(res1)) {
36346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36347 }
36348 arg1 = reinterpret_cast< wxWindow * >(argp1);
36349 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36350 int val;
36351 int ecode = SWIG_AsVal_int(obj1, &val);
36352 if (!SWIG_IsOK(ecode)) {
36353 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36354 }
36355 temp2 = static_cast< int >(val);
36356 arg2 = &temp2;
36357 res2 = SWIG_AddTmpMask(ecode);
36358 }
36359 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36360 int val;
36361 int ecode = SWIG_AsVal_int(obj2, &val);
36362 if (!SWIG_IsOK(ecode)) {
36363 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36364 }
36365 temp3 = static_cast< int >(val);
36366 arg3 = &temp3;
36367 res3 = SWIG_AddTmpMask(ecode);
36368 }
36369 {
36370 PyThreadState* __tstate = wxPyBeginAllowThreads();
36371 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36372 wxPyEndAllowThreads(__tstate);
36373 if (PyErr_Occurred()) SWIG_fail;
36374 }
36375 resultobj = SWIG_Py_Void();
36376 if (SWIG_IsTmpObj(res2)) {
36377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36378 } else {
36379 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36381 }
36382 if (SWIG_IsTmpObj(res3)) {
36383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36384 } else {
36385 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36387 }
36388 return resultobj;
36389 fail:
36390 return NULL;
36391 }
36392
36393
36394 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36395 PyObject *resultobj = 0;
36396 wxWindow *arg1 = (wxWindow *) 0 ;
36397 wxPoint *arg2 = 0 ;
36398 wxPoint result;
36399 void *argp1 = 0 ;
36400 int res1 = 0 ;
36401 wxPoint temp2 ;
36402 PyObject * obj0 = 0 ;
36403 PyObject * obj1 = 0 ;
36404 char * kwnames[] = {
36405 (char *) "self",(char *) "pt", NULL
36406 };
36407
36408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
36409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36410 if (!SWIG_IsOK(res1)) {
36411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36412 }
36413 arg1 = reinterpret_cast< wxWindow * >(argp1);
36414 {
36415 arg2 = &temp2;
36416 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36417 }
36418 {
36419 PyThreadState* __tstate = wxPyBeginAllowThreads();
36420 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36421 wxPyEndAllowThreads(__tstate);
36422 if (PyErr_Occurred()) SWIG_fail;
36423 }
36424 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36425 return resultobj;
36426 fail:
36427 return NULL;
36428 }
36429
36430
36431 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36432 PyObject *resultobj = 0;
36433 wxWindow *arg1 = (wxWindow *) 0 ;
36434 wxPoint *arg2 = 0 ;
36435 wxPoint result;
36436 void *argp1 = 0 ;
36437 int res1 = 0 ;
36438 wxPoint temp2 ;
36439 PyObject * obj0 = 0 ;
36440 PyObject * obj1 = 0 ;
36441 char * kwnames[] = {
36442 (char *) "self",(char *) "pt", NULL
36443 };
36444
36445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36447 if (!SWIG_IsOK(res1)) {
36448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36449 }
36450 arg1 = reinterpret_cast< wxWindow * >(argp1);
36451 {
36452 arg2 = &temp2;
36453 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36454 }
36455 {
36456 PyThreadState* __tstate = wxPyBeginAllowThreads();
36457 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36458 wxPyEndAllowThreads(__tstate);
36459 if (PyErr_Occurred()) SWIG_fail;
36460 }
36461 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36462 return resultobj;
36463 fail:
36464 return NULL;
36465 }
36466
36467
36468 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36469 PyObject *resultobj = 0;
36470 wxWindow *arg1 = (wxWindow *) 0 ;
36471 int arg2 ;
36472 int arg3 ;
36473 wxHitTest result;
36474 void *argp1 = 0 ;
36475 int res1 = 0 ;
36476 int val2 ;
36477 int ecode2 = 0 ;
36478 int val3 ;
36479 int ecode3 = 0 ;
36480 PyObject * obj0 = 0 ;
36481 PyObject * obj1 = 0 ;
36482 PyObject * obj2 = 0 ;
36483 char * kwnames[] = {
36484 (char *) "self",(char *) "x",(char *) "y", NULL
36485 };
36486
36487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36489 if (!SWIG_IsOK(res1)) {
36490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36491 }
36492 arg1 = reinterpret_cast< wxWindow * >(argp1);
36493 ecode2 = SWIG_AsVal_int(obj1, &val2);
36494 if (!SWIG_IsOK(ecode2)) {
36495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36496 }
36497 arg2 = static_cast< int >(val2);
36498 ecode3 = SWIG_AsVal_int(obj2, &val3);
36499 if (!SWIG_IsOK(ecode3)) {
36500 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36501 }
36502 arg3 = static_cast< int >(val3);
36503 {
36504 PyThreadState* __tstate = wxPyBeginAllowThreads();
36505 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36506 wxPyEndAllowThreads(__tstate);
36507 if (PyErr_Occurred()) SWIG_fail;
36508 }
36509 resultobj = SWIG_From_int(static_cast< int >(result));
36510 return resultobj;
36511 fail:
36512 return NULL;
36513 }
36514
36515
36516 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36517 PyObject *resultobj = 0;
36518 wxWindow *arg1 = (wxWindow *) 0 ;
36519 wxPoint *arg2 = 0 ;
36520 wxHitTest result;
36521 void *argp1 = 0 ;
36522 int res1 = 0 ;
36523 wxPoint temp2 ;
36524 PyObject * obj0 = 0 ;
36525 PyObject * obj1 = 0 ;
36526 char * kwnames[] = {
36527 (char *) "self",(char *) "pt", NULL
36528 };
36529
36530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36532 if (!SWIG_IsOK(res1)) {
36533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36534 }
36535 arg1 = reinterpret_cast< wxWindow * >(argp1);
36536 {
36537 arg2 = &temp2;
36538 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36539 }
36540 {
36541 PyThreadState* __tstate = wxPyBeginAllowThreads();
36542 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36543 wxPyEndAllowThreads(__tstate);
36544 if (PyErr_Occurred()) SWIG_fail;
36545 }
36546 resultobj = SWIG_From_int(static_cast< int >(result));
36547 return resultobj;
36548 fail:
36549 return NULL;
36550 }
36551
36552
36553 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36554 PyObject *resultobj = 0;
36555 wxWindow *arg1 = (wxWindow *) 0 ;
36556 long arg2 ;
36557 wxBorder result;
36558 void *argp1 = 0 ;
36559 int res1 = 0 ;
36560 long val2 ;
36561 int ecode2 = 0 ;
36562
36563 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36565 if (!SWIG_IsOK(res1)) {
36566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36567 }
36568 arg1 = reinterpret_cast< wxWindow * >(argp1);
36569 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36570 if (!SWIG_IsOK(ecode2)) {
36571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36572 }
36573 arg2 = static_cast< long >(val2);
36574 {
36575 PyThreadState* __tstate = wxPyBeginAllowThreads();
36576 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36577 wxPyEndAllowThreads(__tstate);
36578 if (PyErr_Occurred()) SWIG_fail;
36579 }
36580 resultobj = SWIG_From_int(static_cast< int >(result));
36581 return resultobj;
36582 fail:
36583 return NULL;
36584 }
36585
36586
36587 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36588 PyObject *resultobj = 0;
36589 wxWindow *arg1 = (wxWindow *) 0 ;
36590 wxBorder result;
36591 void *argp1 = 0 ;
36592 int res1 = 0 ;
36593
36594 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36596 if (!SWIG_IsOK(res1)) {
36597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36598 }
36599 arg1 = reinterpret_cast< wxWindow * >(argp1);
36600 {
36601 PyThreadState* __tstate = wxPyBeginAllowThreads();
36602 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36603 wxPyEndAllowThreads(__tstate);
36604 if (PyErr_Occurred()) SWIG_fail;
36605 }
36606 resultobj = SWIG_From_int(static_cast< int >(result));
36607 return resultobj;
36608 fail:
36609 return NULL;
36610 }
36611
36612
36613 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36614 int argc;
36615 PyObject *argv[3];
36616
36617 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36618 --argc;
36619 if (argc == 1) {
36620 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36621 }
36622 if (argc == 2) {
36623 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36624 }
36625
36626 fail:
36627 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36628 return NULL;
36629 }
36630
36631
36632 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36633 PyObject *resultobj = 0;
36634 wxWindow *arg1 = (wxWindow *) 0 ;
36635 long arg2 = (long) wxUPDATE_UI_NONE ;
36636 void *argp1 = 0 ;
36637 int res1 = 0 ;
36638 long val2 ;
36639 int ecode2 = 0 ;
36640 PyObject * obj0 = 0 ;
36641 PyObject * obj1 = 0 ;
36642 char * kwnames[] = {
36643 (char *) "self",(char *) "flags", NULL
36644 };
36645
36646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36648 if (!SWIG_IsOK(res1)) {
36649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36650 }
36651 arg1 = reinterpret_cast< wxWindow * >(argp1);
36652 if (obj1) {
36653 ecode2 = SWIG_AsVal_long(obj1, &val2);
36654 if (!SWIG_IsOK(ecode2)) {
36655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36656 }
36657 arg2 = static_cast< long >(val2);
36658 }
36659 {
36660 PyThreadState* __tstate = wxPyBeginAllowThreads();
36661 (arg1)->UpdateWindowUI(arg2);
36662 wxPyEndAllowThreads(__tstate);
36663 if (PyErr_Occurred()) SWIG_fail;
36664 }
36665 resultobj = SWIG_Py_Void();
36666 return resultobj;
36667 fail:
36668 return NULL;
36669 }
36670
36671
36672 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36673 PyObject *resultobj = 0;
36674 wxWindow *arg1 = (wxWindow *) 0 ;
36675 wxMenu *arg2 = (wxMenu *) 0 ;
36676 int arg3 = (int) -1 ;
36677 int arg4 = (int) -1 ;
36678 bool result;
36679 void *argp1 = 0 ;
36680 int res1 = 0 ;
36681 void *argp2 = 0 ;
36682 int res2 = 0 ;
36683 int val3 ;
36684 int ecode3 = 0 ;
36685 int val4 ;
36686 int ecode4 = 0 ;
36687 PyObject * obj0 = 0 ;
36688 PyObject * obj1 = 0 ;
36689 PyObject * obj2 = 0 ;
36690 PyObject * obj3 = 0 ;
36691 char * kwnames[] = {
36692 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36693 };
36694
36695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36699 }
36700 arg1 = reinterpret_cast< wxWindow * >(argp1);
36701 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36702 if (!SWIG_IsOK(res2)) {
36703 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36704 }
36705 arg2 = reinterpret_cast< wxMenu * >(argp2);
36706 if (obj2) {
36707 ecode3 = SWIG_AsVal_int(obj2, &val3);
36708 if (!SWIG_IsOK(ecode3)) {
36709 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36710 }
36711 arg3 = static_cast< int >(val3);
36712 }
36713 if (obj3) {
36714 ecode4 = SWIG_AsVal_int(obj3, &val4);
36715 if (!SWIG_IsOK(ecode4)) {
36716 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36717 }
36718 arg4 = static_cast< int >(val4);
36719 }
36720 {
36721 PyThreadState* __tstate = wxPyBeginAllowThreads();
36722 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36723 wxPyEndAllowThreads(__tstate);
36724 if (PyErr_Occurred()) SWIG_fail;
36725 }
36726 {
36727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36728 }
36729 return resultobj;
36730 fail:
36731 return NULL;
36732 }
36733
36734
36735 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36736 PyObject *resultobj = 0;
36737 wxWindow *arg1 = (wxWindow *) 0 ;
36738 wxMenu *arg2 = (wxMenu *) 0 ;
36739 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36740 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36741 bool result;
36742 void *argp1 = 0 ;
36743 int res1 = 0 ;
36744 void *argp2 = 0 ;
36745 int res2 = 0 ;
36746 wxPoint temp3 ;
36747 PyObject * obj0 = 0 ;
36748 PyObject * obj1 = 0 ;
36749 PyObject * obj2 = 0 ;
36750 char * kwnames[] = {
36751 (char *) "self",(char *) "menu",(char *) "pos", NULL
36752 };
36753
36754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36756 if (!SWIG_IsOK(res1)) {
36757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36758 }
36759 arg1 = reinterpret_cast< wxWindow * >(argp1);
36760 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36761 if (!SWIG_IsOK(res2)) {
36762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36763 }
36764 arg2 = reinterpret_cast< wxMenu * >(argp2);
36765 if (obj2) {
36766 {
36767 arg3 = &temp3;
36768 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36769 }
36770 }
36771 {
36772 PyThreadState* __tstate = wxPyBeginAllowThreads();
36773 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36774 wxPyEndAllowThreads(__tstate);
36775 if (PyErr_Occurred()) SWIG_fail;
36776 }
36777 {
36778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36779 }
36780 return resultobj;
36781 fail:
36782 return NULL;
36783 }
36784
36785
36786 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36787 PyObject *resultobj = 0;
36788 wxWindow *arg1 = (wxWindow *) 0 ;
36789 bool result;
36790 void *argp1 = 0 ;
36791 int res1 = 0 ;
36792 PyObject *swig_obj[1] ;
36793
36794 if (!args) SWIG_fail;
36795 swig_obj[0] = args;
36796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36797 if (!SWIG_IsOK(res1)) {
36798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36799 }
36800 arg1 = reinterpret_cast< wxWindow * >(argp1);
36801 {
36802 PyThreadState* __tstate = wxPyBeginAllowThreads();
36803 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36804 wxPyEndAllowThreads(__tstate);
36805 if (PyErr_Occurred()) SWIG_fail;
36806 }
36807 {
36808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36809 }
36810 return resultobj;
36811 fail:
36812 return NULL;
36813 }
36814
36815
36816 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36817 PyObject *resultobj = 0;
36818 wxWindow *arg1 = (wxWindow *) 0 ;
36819 long result;
36820 void *argp1 = 0 ;
36821 int res1 = 0 ;
36822 PyObject *swig_obj[1] ;
36823
36824 if (!args) SWIG_fail;
36825 swig_obj[0] = args;
36826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36827 if (!SWIG_IsOK(res1)) {
36828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36829 }
36830 arg1 = reinterpret_cast< wxWindow * >(argp1);
36831 {
36832 PyThreadState* __tstate = wxPyBeginAllowThreads();
36833 result = (long)wxWindow_GetHandle(arg1);
36834 wxPyEndAllowThreads(__tstate);
36835 if (PyErr_Occurred()) SWIG_fail;
36836 }
36837 resultobj = SWIG_From_long(static_cast< long >(result));
36838 return resultobj;
36839 fail:
36840 return NULL;
36841 }
36842
36843
36844 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36845 PyObject *resultobj = 0;
36846 wxWindow *arg1 = (wxWindow *) 0 ;
36847 long arg2 ;
36848 void *argp1 = 0 ;
36849 int res1 = 0 ;
36850 long val2 ;
36851 int ecode2 = 0 ;
36852 PyObject * obj0 = 0 ;
36853 PyObject * obj1 = 0 ;
36854 char * kwnames[] = {
36855 (char *) "self",(char *) "handle", NULL
36856 };
36857
36858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36860 if (!SWIG_IsOK(res1)) {
36861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36862 }
36863 arg1 = reinterpret_cast< wxWindow * >(argp1);
36864 ecode2 = SWIG_AsVal_long(obj1, &val2);
36865 if (!SWIG_IsOK(ecode2)) {
36866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36867 }
36868 arg2 = static_cast< long >(val2);
36869 {
36870 PyThreadState* __tstate = wxPyBeginAllowThreads();
36871 wxWindow_AssociateHandle(arg1,arg2);
36872 wxPyEndAllowThreads(__tstate);
36873 if (PyErr_Occurred()) SWIG_fail;
36874 }
36875 resultobj = SWIG_Py_Void();
36876 return resultobj;
36877 fail:
36878 return NULL;
36879 }
36880
36881
36882 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36883 PyObject *resultobj = 0;
36884 wxWindow *arg1 = (wxWindow *) 0 ;
36885 void *argp1 = 0 ;
36886 int res1 = 0 ;
36887 PyObject *swig_obj[1] ;
36888
36889 if (!args) SWIG_fail;
36890 swig_obj[0] = args;
36891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36892 if (!SWIG_IsOK(res1)) {
36893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36894 }
36895 arg1 = reinterpret_cast< wxWindow * >(argp1);
36896 {
36897 PyThreadState* __tstate = wxPyBeginAllowThreads();
36898 (arg1)->DissociateHandle();
36899 wxPyEndAllowThreads(__tstate);
36900 if (PyErr_Occurred()) SWIG_fail;
36901 }
36902 resultobj = SWIG_Py_Void();
36903 return resultobj;
36904 fail:
36905 return NULL;
36906 }
36907
36908
36909 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36910 PyObject *resultobj = 0;
36911 wxWindow *arg1 = (wxWindow *) 0 ;
36912 int arg2 ;
36913 bool result;
36914 void *argp1 = 0 ;
36915 int res1 = 0 ;
36916 int val2 ;
36917 int ecode2 = 0 ;
36918 PyObject * obj0 = 0 ;
36919 PyObject * obj1 = 0 ;
36920 char * kwnames[] = {
36921 (char *) "self",(char *) "orient", NULL
36922 };
36923
36924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36926 if (!SWIG_IsOK(res1)) {
36927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36928 }
36929 arg1 = reinterpret_cast< wxWindow * >(argp1);
36930 ecode2 = SWIG_AsVal_int(obj1, &val2);
36931 if (!SWIG_IsOK(ecode2)) {
36932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36933 }
36934 arg2 = static_cast< int >(val2);
36935 {
36936 PyThreadState* __tstate = wxPyBeginAllowThreads();
36937 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36938 wxPyEndAllowThreads(__tstate);
36939 if (PyErr_Occurred()) SWIG_fail;
36940 }
36941 {
36942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36943 }
36944 return resultobj;
36945 fail:
36946 return NULL;
36947 }
36948
36949
36950 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36951 PyObject *resultobj = 0;
36952 wxWindow *arg1 = (wxWindow *) 0 ;
36953 int arg2 ;
36954 int arg3 ;
36955 int arg4 ;
36956 int arg5 ;
36957 bool arg6 = (bool) true ;
36958 void *argp1 = 0 ;
36959 int res1 = 0 ;
36960 int val2 ;
36961 int ecode2 = 0 ;
36962 int val3 ;
36963 int ecode3 = 0 ;
36964 int val4 ;
36965 int ecode4 = 0 ;
36966 int val5 ;
36967 int ecode5 = 0 ;
36968 bool val6 ;
36969 int ecode6 = 0 ;
36970 PyObject * obj0 = 0 ;
36971 PyObject * obj1 = 0 ;
36972 PyObject * obj2 = 0 ;
36973 PyObject * obj3 = 0 ;
36974 PyObject * obj4 = 0 ;
36975 PyObject * obj5 = 0 ;
36976 char * kwnames[] = {
36977 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36978 };
36979
36980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36982 if (!SWIG_IsOK(res1)) {
36983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36984 }
36985 arg1 = reinterpret_cast< wxWindow * >(argp1);
36986 ecode2 = SWIG_AsVal_int(obj1, &val2);
36987 if (!SWIG_IsOK(ecode2)) {
36988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36989 }
36990 arg2 = static_cast< int >(val2);
36991 ecode3 = SWIG_AsVal_int(obj2, &val3);
36992 if (!SWIG_IsOK(ecode3)) {
36993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36994 }
36995 arg3 = static_cast< int >(val3);
36996 ecode4 = SWIG_AsVal_int(obj3, &val4);
36997 if (!SWIG_IsOK(ecode4)) {
36998 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36999 }
37000 arg4 = static_cast< int >(val4);
37001 ecode5 = SWIG_AsVal_int(obj4, &val5);
37002 if (!SWIG_IsOK(ecode5)) {
37003 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37004 }
37005 arg5 = static_cast< int >(val5);
37006 if (obj5) {
37007 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37008 if (!SWIG_IsOK(ecode6)) {
37009 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37010 }
37011 arg6 = static_cast< bool >(val6);
37012 }
37013 {
37014 PyThreadState* __tstate = wxPyBeginAllowThreads();
37015 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37016 wxPyEndAllowThreads(__tstate);
37017 if (PyErr_Occurred()) SWIG_fail;
37018 }
37019 resultobj = SWIG_Py_Void();
37020 return resultobj;
37021 fail:
37022 return NULL;
37023 }
37024
37025
37026 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37027 PyObject *resultobj = 0;
37028 wxWindow *arg1 = (wxWindow *) 0 ;
37029 int arg2 ;
37030 int arg3 ;
37031 bool arg4 = (bool) true ;
37032 void *argp1 = 0 ;
37033 int res1 = 0 ;
37034 int val2 ;
37035 int ecode2 = 0 ;
37036 int val3 ;
37037 int ecode3 = 0 ;
37038 bool val4 ;
37039 int ecode4 = 0 ;
37040 PyObject * obj0 = 0 ;
37041 PyObject * obj1 = 0 ;
37042 PyObject * obj2 = 0 ;
37043 PyObject * obj3 = 0 ;
37044 char * kwnames[] = {
37045 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37046 };
37047
37048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37050 if (!SWIG_IsOK(res1)) {
37051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37052 }
37053 arg1 = reinterpret_cast< wxWindow * >(argp1);
37054 ecode2 = SWIG_AsVal_int(obj1, &val2);
37055 if (!SWIG_IsOK(ecode2)) {
37056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37057 }
37058 arg2 = static_cast< int >(val2);
37059 ecode3 = SWIG_AsVal_int(obj2, &val3);
37060 if (!SWIG_IsOK(ecode3)) {
37061 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37062 }
37063 arg3 = static_cast< int >(val3);
37064 if (obj3) {
37065 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37066 if (!SWIG_IsOK(ecode4)) {
37067 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37068 }
37069 arg4 = static_cast< bool >(val4);
37070 }
37071 {
37072 PyThreadState* __tstate = wxPyBeginAllowThreads();
37073 (arg1)->SetScrollPos(arg2,arg3,arg4);
37074 wxPyEndAllowThreads(__tstate);
37075 if (PyErr_Occurred()) SWIG_fail;
37076 }
37077 resultobj = SWIG_Py_Void();
37078 return resultobj;
37079 fail:
37080 return NULL;
37081 }
37082
37083
37084 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37085 PyObject *resultobj = 0;
37086 wxWindow *arg1 = (wxWindow *) 0 ;
37087 int arg2 ;
37088 int result;
37089 void *argp1 = 0 ;
37090 int res1 = 0 ;
37091 int val2 ;
37092 int ecode2 = 0 ;
37093 PyObject * obj0 = 0 ;
37094 PyObject * obj1 = 0 ;
37095 char * kwnames[] = {
37096 (char *) "self",(char *) "orientation", NULL
37097 };
37098
37099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37101 if (!SWIG_IsOK(res1)) {
37102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37103 }
37104 arg1 = reinterpret_cast< wxWindow * >(argp1);
37105 ecode2 = SWIG_AsVal_int(obj1, &val2);
37106 if (!SWIG_IsOK(ecode2)) {
37107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37108 }
37109 arg2 = static_cast< int >(val2);
37110 {
37111 PyThreadState* __tstate = wxPyBeginAllowThreads();
37112 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37113 wxPyEndAllowThreads(__tstate);
37114 if (PyErr_Occurred()) SWIG_fail;
37115 }
37116 resultobj = SWIG_From_int(static_cast< int >(result));
37117 return resultobj;
37118 fail:
37119 return NULL;
37120 }
37121
37122
37123 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37124 PyObject *resultobj = 0;
37125 wxWindow *arg1 = (wxWindow *) 0 ;
37126 int arg2 ;
37127 int result;
37128 void *argp1 = 0 ;
37129 int res1 = 0 ;
37130 int val2 ;
37131 int ecode2 = 0 ;
37132 PyObject * obj0 = 0 ;
37133 PyObject * obj1 = 0 ;
37134 char * kwnames[] = {
37135 (char *) "self",(char *) "orientation", NULL
37136 };
37137
37138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37140 if (!SWIG_IsOK(res1)) {
37141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37142 }
37143 arg1 = reinterpret_cast< wxWindow * >(argp1);
37144 ecode2 = SWIG_AsVal_int(obj1, &val2);
37145 if (!SWIG_IsOK(ecode2)) {
37146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37147 }
37148 arg2 = static_cast< int >(val2);
37149 {
37150 PyThreadState* __tstate = wxPyBeginAllowThreads();
37151 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37152 wxPyEndAllowThreads(__tstate);
37153 if (PyErr_Occurred()) SWIG_fail;
37154 }
37155 resultobj = SWIG_From_int(static_cast< int >(result));
37156 return resultobj;
37157 fail:
37158 return NULL;
37159 }
37160
37161
37162 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37163 PyObject *resultobj = 0;
37164 wxWindow *arg1 = (wxWindow *) 0 ;
37165 int arg2 ;
37166 int result;
37167 void *argp1 = 0 ;
37168 int res1 = 0 ;
37169 int val2 ;
37170 int ecode2 = 0 ;
37171 PyObject * obj0 = 0 ;
37172 PyObject * obj1 = 0 ;
37173 char * kwnames[] = {
37174 (char *) "self",(char *) "orientation", NULL
37175 };
37176
37177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37179 if (!SWIG_IsOK(res1)) {
37180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37181 }
37182 arg1 = reinterpret_cast< wxWindow * >(argp1);
37183 ecode2 = SWIG_AsVal_int(obj1, &val2);
37184 if (!SWIG_IsOK(ecode2)) {
37185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37186 }
37187 arg2 = static_cast< int >(val2);
37188 {
37189 PyThreadState* __tstate = wxPyBeginAllowThreads();
37190 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37191 wxPyEndAllowThreads(__tstate);
37192 if (PyErr_Occurred()) SWIG_fail;
37193 }
37194 resultobj = SWIG_From_int(static_cast< int >(result));
37195 return resultobj;
37196 fail:
37197 return NULL;
37198 }
37199
37200
37201 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37202 PyObject *resultobj = 0;
37203 wxWindow *arg1 = (wxWindow *) 0 ;
37204 int arg2 ;
37205 int arg3 ;
37206 wxRect *arg4 = (wxRect *) NULL ;
37207 void *argp1 = 0 ;
37208 int res1 = 0 ;
37209 int val2 ;
37210 int ecode2 = 0 ;
37211 int val3 ;
37212 int ecode3 = 0 ;
37213 void *argp4 = 0 ;
37214 int res4 = 0 ;
37215 PyObject * obj0 = 0 ;
37216 PyObject * obj1 = 0 ;
37217 PyObject * obj2 = 0 ;
37218 PyObject * obj3 = 0 ;
37219 char * kwnames[] = {
37220 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37221 };
37222
37223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37225 if (!SWIG_IsOK(res1)) {
37226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37227 }
37228 arg1 = reinterpret_cast< wxWindow * >(argp1);
37229 ecode2 = SWIG_AsVal_int(obj1, &val2);
37230 if (!SWIG_IsOK(ecode2)) {
37231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37232 }
37233 arg2 = static_cast< int >(val2);
37234 ecode3 = SWIG_AsVal_int(obj2, &val3);
37235 if (!SWIG_IsOK(ecode3)) {
37236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37237 }
37238 arg3 = static_cast< int >(val3);
37239 if (obj3) {
37240 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37241 if (!SWIG_IsOK(res4)) {
37242 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37243 }
37244 arg4 = reinterpret_cast< wxRect * >(argp4);
37245 }
37246 {
37247 PyThreadState* __tstate = wxPyBeginAllowThreads();
37248 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37249 wxPyEndAllowThreads(__tstate);
37250 if (PyErr_Occurred()) SWIG_fail;
37251 }
37252 resultobj = SWIG_Py_Void();
37253 return resultobj;
37254 fail:
37255 return NULL;
37256 }
37257
37258
37259 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37260 PyObject *resultobj = 0;
37261 wxWindow *arg1 = (wxWindow *) 0 ;
37262 int arg2 ;
37263 bool result;
37264 void *argp1 = 0 ;
37265 int res1 = 0 ;
37266 int val2 ;
37267 int ecode2 = 0 ;
37268 PyObject * obj0 = 0 ;
37269 PyObject * obj1 = 0 ;
37270 char * kwnames[] = {
37271 (char *) "self",(char *) "lines", NULL
37272 };
37273
37274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37276 if (!SWIG_IsOK(res1)) {
37277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37278 }
37279 arg1 = reinterpret_cast< wxWindow * >(argp1);
37280 ecode2 = SWIG_AsVal_int(obj1, &val2);
37281 if (!SWIG_IsOK(ecode2)) {
37282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37283 }
37284 arg2 = static_cast< int >(val2);
37285 {
37286 PyThreadState* __tstate = wxPyBeginAllowThreads();
37287 result = (bool)(arg1)->ScrollLines(arg2);
37288 wxPyEndAllowThreads(__tstate);
37289 if (PyErr_Occurred()) SWIG_fail;
37290 }
37291 {
37292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37293 }
37294 return resultobj;
37295 fail:
37296 return NULL;
37297 }
37298
37299
37300 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37301 PyObject *resultobj = 0;
37302 wxWindow *arg1 = (wxWindow *) 0 ;
37303 int arg2 ;
37304 bool result;
37305 void *argp1 = 0 ;
37306 int res1 = 0 ;
37307 int val2 ;
37308 int ecode2 = 0 ;
37309 PyObject * obj0 = 0 ;
37310 PyObject * obj1 = 0 ;
37311 char * kwnames[] = {
37312 (char *) "self",(char *) "pages", NULL
37313 };
37314
37315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37317 if (!SWIG_IsOK(res1)) {
37318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37319 }
37320 arg1 = reinterpret_cast< wxWindow * >(argp1);
37321 ecode2 = SWIG_AsVal_int(obj1, &val2);
37322 if (!SWIG_IsOK(ecode2)) {
37323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37324 }
37325 arg2 = static_cast< int >(val2);
37326 {
37327 PyThreadState* __tstate = wxPyBeginAllowThreads();
37328 result = (bool)(arg1)->ScrollPages(arg2);
37329 wxPyEndAllowThreads(__tstate);
37330 if (PyErr_Occurred()) SWIG_fail;
37331 }
37332 {
37333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37334 }
37335 return resultobj;
37336 fail:
37337 return NULL;
37338 }
37339
37340
37341 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37342 PyObject *resultobj = 0;
37343 wxWindow *arg1 = (wxWindow *) 0 ;
37344 bool result;
37345 void *argp1 = 0 ;
37346 int res1 = 0 ;
37347 PyObject *swig_obj[1] ;
37348
37349 if (!args) SWIG_fail;
37350 swig_obj[0] = args;
37351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37352 if (!SWIG_IsOK(res1)) {
37353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37354 }
37355 arg1 = reinterpret_cast< wxWindow * >(argp1);
37356 {
37357 PyThreadState* __tstate = wxPyBeginAllowThreads();
37358 result = (bool)(arg1)->LineUp();
37359 wxPyEndAllowThreads(__tstate);
37360 if (PyErr_Occurred()) SWIG_fail;
37361 }
37362 {
37363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37364 }
37365 return resultobj;
37366 fail:
37367 return NULL;
37368 }
37369
37370
37371 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37372 PyObject *resultobj = 0;
37373 wxWindow *arg1 = (wxWindow *) 0 ;
37374 bool result;
37375 void *argp1 = 0 ;
37376 int res1 = 0 ;
37377 PyObject *swig_obj[1] ;
37378
37379 if (!args) SWIG_fail;
37380 swig_obj[0] = args;
37381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37382 if (!SWIG_IsOK(res1)) {
37383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37384 }
37385 arg1 = reinterpret_cast< wxWindow * >(argp1);
37386 {
37387 PyThreadState* __tstate = wxPyBeginAllowThreads();
37388 result = (bool)(arg1)->LineDown();
37389 wxPyEndAllowThreads(__tstate);
37390 if (PyErr_Occurred()) SWIG_fail;
37391 }
37392 {
37393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37394 }
37395 return resultobj;
37396 fail:
37397 return NULL;
37398 }
37399
37400
37401 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37402 PyObject *resultobj = 0;
37403 wxWindow *arg1 = (wxWindow *) 0 ;
37404 bool result;
37405 void *argp1 = 0 ;
37406 int res1 = 0 ;
37407 PyObject *swig_obj[1] ;
37408
37409 if (!args) SWIG_fail;
37410 swig_obj[0] = args;
37411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37412 if (!SWIG_IsOK(res1)) {
37413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37414 }
37415 arg1 = reinterpret_cast< wxWindow * >(argp1);
37416 {
37417 PyThreadState* __tstate = wxPyBeginAllowThreads();
37418 result = (bool)(arg1)->PageUp();
37419 wxPyEndAllowThreads(__tstate);
37420 if (PyErr_Occurred()) SWIG_fail;
37421 }
37422 {
37423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37424 }
37425 return resultobj;
37426 fail:
37427 return NULL;
37428 }
37429
37430
37431 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37432 PyObject *resultobj = 0;
37433 wxWindow *arg1 = (wxWindow *) 0 ;
37434 bool result;
37435 void *argp1 = 0 ;
37436 int res1 = 0 ;
37437 PyObject *swig_obj[1] ;
37438
37439 if (!args) SWIG_fail;
37440 swig_obj[0] = args;
37441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37442 if (!SWIG_IsOK(res1)) {
37443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37444 }
37445 arg1 = reinterpret_cast< wxWindow * >(argp1);
37446 {
37447 PyThreadState* __tstate = wxPyBeginAllowThreads();
37448 result = (bool)(arg1)->PageDown();
37449 wxPyEndAllowThreads(__tstate);
37450 if (PyErr_Occurred()) SWIG_fail;
37451 }
37452 {
37453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37454 }
37455 return resultobj;
37456 fail:
37457 return NULL;
37458 }
37459
37460
37461 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37462 PyObject *resultobj = 0;
37463 wxWindow *arg1 = (wxWindow *) 0 ;
37464 wxString *arg2 = 0 ;
37465 void *argp1 = 0 ;
37466 int res1 = 0 ;
37467 bool temp2 = false ;
37468 PyObject * obj0 = 0 ;
37469 PyObject * obj1 = 0 ;
37470 char * kwnames[] = {
37471 (char *) "self",(char *) "text", NULL
37472 };
37473
37474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37476 if (!SWIG_IsOK(res1)) {
37477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37478 }
37479 arg1 = reinterpret_cast< wxWindow * >(argp1);
37480 {
37481 arg2 = wxString_in_helper(obj1);
37482 if (arg2 == NULL) SWIG_fail;
37483 temp2 = true;
37484 }
37485 {
37486 PyThreadState* __tstate = wxPyBeginAllowThreads();
37487 (arg1)->SetHelpText((wxString const &)*arg2);
37488 wxPyEndAllowThreads(__tstate);
37489 if (PyErr_Occurred()) SWIG_fail;
37490 }
37491 resultobj = SWIG_Py_Void();
37492 {
37493 if (temp2)
37494 delete arg2;
37495 }
37496 return resultobj;
37497 fail:
37498 {
37499 if (temp2)
37500 delete arg2;
37501 }
37502 return NULL;
37503 }
37504
37505
37506 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37507 PyObject *resultobj = 0;
37508 wxWindow *arg1 = (wxWindow *) 0 ;
37509 wxString *arg2 = 0 ;
37510 void *argp1 = 0 ;
37511 int res1 = 0 ;
37512 bool temp2 = false ;
37513 PyObject * obj0 = 0 ;
37514 PyObject * obj1 = 0 ;
37515 char * kwnames[] = {
37516 (char *) "self",(char *) "text", NULL
37517 };
37518
37519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37521 if (!SWIG_IsOK(res1)) {
37522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37523 }
37524 arg1 = reinterpret_cast< wxWindow * >(argp1);
37525 {
37526 arg2 = wxString_in_helper(obj1);
37527 if (arg2 == NULL) SWIG_fail;
37528 temp2 = true;
37529 }
37530 {
37531 PyThreadState* __tstate = wxPyBeginAllowThreads();
37532 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37533 wxPyEndAllowThreads(__tstate);
37534 if (PyErr_Occurred()) SWIG_fail;
37535 }
37536 resultobj = SWIG_Py_Void();
37537 {
37538 if (temp2)
37539 delete arg2;
37540 }
37541 return resultobj;
37542 fail:
37543 {
37544 if (temp2)
37545 delete arg2;
37546 }
37547 return NULL;
37548 }
37549
37550
37551 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37552 PyObject *resultobj = 0;
37553 wxWindow *arg1 = (wxWindow *) 0 ;
37554 wxPoint *arg2 = 0 ;
37555 wxHelpEvent::Origin arg3 ;
37556 wxString result;
37557 void *argp1 = 0 ;
37558 int res1 = 0 ;
37559 wxPoint temp2 ;
37560 void *argp3 ;
37561 int res3 = 0 ;
37562 PyObject * obj0 = 0 ;
37563 PyObject * obj1 = 0 ;
37564 PyObject * obj2 = 0 ;
37565 char * kwnames[] = {
37566 (char *) "self",(char *) "pt",(char *) "origin", NULL
37567 };
37568
37569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37571 if (!SWIG_IsOK(res1)) {
37572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37573 }
37574 arg1 = reinterpret_cast< wxWindow * >(argp1);
37575 {
37576 arg2 = &temp2;
37577 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37578 }
37579 {
37580 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37581 if (!SWIG_IsOK(res3)) {
37582 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37583 }
37584 if (!argp3) {
37585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37586 } else {
37587 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37588 arg3 = *temp;
37589 if (SWIG_IsNewObj(res3)) delete temp;
37590 }
37591 }
37592 {
37593 PyThreadState* __tstate = wxPyBeginAllowThreads();
37594 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37595 wxPyEndAllowThreads(__tstate);
37596 if (PyErr_Occurred()) SWIG_fail;
37597 }
37598 {
37599 #if wxUSE_UNICODE
37600 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37601 #else
37602 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37603 #endif
37604 }
37605 return resultobj;
37606 fail:
37607 return NULL;
37608 }
37609
37610
37611 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37612 PyObject *resultobj = 0;
37613 wxWindow *arg1 = (wxWindow *) 0 ;
37614 wxString result;
37615 void *argp1 = 0 ;
37616 int res1 = 0 ;
37617 PyObject *swig_obj[1] ;
37618
37619 if (!args) SWIG_fail;
37620 swig_obj[0] = args;
37621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37622 if (!SWIG_IsOK(res1)) {
37623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37624 }
37625 arg1 = reinterpret_cast< wxWindow * >(argp1);
37626 {
37627 PyThreadState* __tstate = wxPyBeginAllowThreads();
37628 result = ((wxWindow const *)arg1)->GetHelpText();
37629 wxPyEndAllowThreads(__tstate);
37630 if (PyErr_Occurred()) SWIG_fail;
37631 }
37632 {
37633 #if wxUSE_UNICODE
37634 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37635 #else
37636 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37637 #endif
37638 }
37639 return resultobj;
37640 fail:
37641 return NULL;
37642 }
37643
37644
37645 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37646 PyObject *resultobj = 0;
37647 wxWindow *arg1 = (wxWindow *) 0 ;
37648 wxString *arg2 = 0 ;
37649 void *argp1 = 0 ;
37650 int res1 = 0 ;
37651 bool temp2 = false ;
37652 PyObject * obj0 = 0 ;
37653 PyObject * obj1 = 0 ;
37654 char * kwnames[] = {
37655 (char *) "self",(char *) "tip", NULL
37656 };
37657
37658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37660 if (!SWIG_IsOK(res1)) {
37661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37662 }
37663 arg1 = reinterpret_cast< wxWindow * >(argp1);
37664 {
37665 arg2 = wxString_in_helper(obj1);
37666 if (arg2 == NULL) SWIG_fail;
37667 temp2 = true;
37668 }
37669 {
37670 PyThreadState* __tstate = wxPyBeginAllowThreads();
37671 (arg1)->SetToolTip((wxString const &)*arg2);
37672 wxPyEndAllowThreads(__tstate);
37673 if (PyErr_Occurred()) SWIG_fail;
37674 }
37675 resultobj = SWIG_Py_Void();
37676 {
37677 if (temp2)
37678 delete arg2;
37679 }
37680 return resultobj;
37681 fail:
37682 {
37683 if (temp2)
37684 delete arg2;
37685 }
37686 return NULL;
37687 }
37688
37689
37690 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37691 PyObject *resultobj = 0;
37692 wxWindow *arg1 = (wxWindow *) 0 ;
37693 wxToolTip *arg2 = (wxToolTip *) 0 ;
37694 void *argp1 = 0 ;
37695 int res1 = 0 ;
37696 int res2 = 0 ;
37697 PyObject * obj0 = 0 ;
37698 PyObject * obj1 = 0 ;
37699 char * kwnames[] = {
37700 (char *) "self",(char *) "tip", NULL
37701 };
37702
37703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37705 if (!SWIG_IsOK(res1)) {
37706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37707 }
37708 arg1 = reinterpret_cast< wxWindow * >(argp1);
37709 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37710 if (!SWIG_IsOK(res2)) {
37711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37712 }
37713 {
37714 PyThreadState* __tstate = wxPyBeginAllowThreads();
37715 (arg1)->SetToolTip(arg2);
37716 wxPyEndAllowThreads(__tstate);
37717 if (PyErr_Occurred()) SWIG_fail;
37718 }
37719 resultobj = SWIG_Py_Void();
37720 return resultobj;
37721 fail:
37722 return NULL;
37723 }
37724
37725
37726 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37727 PyObject *resultobj = 0;
37728 wxWindow *arg1 = (wxWindow *) 0 ;
37729 wxToolTip *result = 0 ;
37730 void *argp1 = 0 ;
37731 int res1 = 0 ;
37732 PyObject *swig_obj[1] ;
37733
37734 if (!args) SWIG_fail;
37735 swig_obj[0] = args;
37736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37737 if (!SWIG_IsOK(res1)) {
37738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37739 }
37740 arg1 = reinterpret_cast< wxWindow * >(argp1);
37741 {
37742 PyThreadState* __tstate = wxPyBeginAllowThreads();
37743 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37744 wxPyEndAllowThreads(__tstate);
37745 if (PyErr_Occurred()) SWIG_fail;
37746 }
37747 {
37748 resultobj = wxPyMake_wxObject(result, (bool)0);
37749 }
37750 return resultobj;
37751 fail:
37752 return NULL;
37753 }
37754
37755
37756 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37757 PyObject *resultobj = 0;
37758 wxWindow *arg1 = (wxWindow *) 0 ;
37759 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37760 void *argp1 = 0 ;
37761 int res1 = 0 ;
37762 int res2 = 0 ;
37763 PyObject * obj0 = 0 ;
37764 PyObject * obj1 = 0 ;
37765 char * kwnames[] = {
37766 (char *) "self",(char *) "dropTarget", NULL
37767 };
37768
37769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37771 if (!SWIG_IsOK(res1)) {
37772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37773 }
37774 arg1 = reinterpret_cast< wxWindow * >(argp1);
37775 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37776 if (!SWIG_IsOK(res2)) {
37777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37778 }
37779 {
37780 PyThreadState* __tstate = wxPyBeginAllowThreads();
37781 (arg1)->SetDropTarget(arg2);
37782 wxPyEndAllowThreads(__tstate);
37783 if (PyErr_Occurred()) SWIG_fail;
37784 }
37785 resultobj = SWIG_Py_Void();
37786 return resultobj;
37787 fail:
37788 return NULL;
37789 }
37790
37791
37792 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37793 PyObject *resultobj = 0;
37794 wxWindow *arg1 = (wxWindow *) 0 ;
37795 wxPyDropTarget *result = 0 ;
37796 void *argp1 = 0 ;
37797 int res1 = 0 ;
37798 PyObject *swig_obj[1] ;
37799
37800 if (!args) SWIG_fail;
37801 swig_obj[0] = args;
37802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37803 if (!SWIG_IsOK(res1)) {
37804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37805 }
37806 arg1 = reinterpret_cast< wxWindow * >(argp1);
37807 {
37808 PyThreadState* __tstate = wxPyBeginAllowThreads();
37809 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37810 wxPyEndAllowThreads(__tstate);
37811 if (PyErr_Occurred()) SWIG_fail;
37812 }
37813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37814 return resultobj;
37815 fail:
37816 return NULL;
37817 }
37818
37819
37820 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37821 PyObject *resultobj = 0;
37822 wxWindow *arg1 = (wxWindow *) 0 ;
37823 bool arg2 ;
37824 void *argp1 = 0 ;
37825 int res1 = 0 ;
37826 bool val2 ;
37827 int ecode2 = 0 ;
37828 PyObject * obj0 = 0 ;
37829 PyObject * obj1 = 0 ;
37830 char * kwnames[] = {
37831 (char *) "self",(char *) "accept", NULL
37832 };
37833
37834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37836 if (!SWIG_IsOK(res1)) {
37837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37838 }
37839 arg1 = reinterpret_cast< wxWindow * >(argp1);
37840 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37841 if (!SWIG_IsOK(ecode2)) {
37842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37843 }
37844 arg2 = static_cast< bool >(val2);
37845 {
37846 PyThreadState* __tstate = wxPyBeginAllowThreads();
37847 wxWindow_DragAcceptFiles(arg1,arg2);
37848 wxPyEndAllowThreads(__tstate);
37849 if (PyErr_Occurred()) SWIG_fail;
37850 }
37851 resultobj = SWIG_Py_Void();
37852 return resultobj;
37853 fail:
37854 return NULL;
37855 }
37856
37857
37858 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37859 PyObject *resultobj = 0;
37860 wxWindow *arg1 = (wxWindow *) 0 ;
37861 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37862 void *argp1 = 0 ;
37863 int res1 = 0 ;
37864 int res2 = 0 ;
37865 PyObject * obj0 = 0 ;
37866 PyObject * obj1 = 0 ;
37867 char * kwnames[] = {
37868 (char *) "self",(char *) "constraints", NULL
37869 };
37870
37871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37873 if (!SWIG_IsOK(res1)) {
37874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37875 }
37876 arg1 = reinterpret_cast< wxWindow * >(argp1);
37877 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37878 if (!SWIG_IsOK(res2)) {
37879 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37880 }
37881 {
37882 PyThreadState* __tstate = wxPyBeginAllowThreads();
37883 (arg1)->SetConstraints(arg2);
37884 wxPyEndAllowThreads(__tstate);
37885 if (PyErr_Occurred()) SWIG_fail;
37886 }
37887 resultobj = SWIG_Py_Void();
37888 return resultobj;
37889 fail:
37890 return NULL;
37891 }
37892
37893
37894 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37895 PyObject *resultobj = 0;
37896 wxWindow *arg1 = (wxWindow *) 0 ;
37897 wxLayoutConstraints *result = 0 ;
37898 void *argp1 = 0 ;
37899 int res1 = 0 ;
37900 PyObject *swig_obj[1] ;
37901
37902 if (!args) SWIG_fail;
37903 swig_obj[0] = args;
37904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37905 if (!SWIG_IsOK(res1)) {
37906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37907 }
37908 arg1 = reinterpret_cast< wxWindow * >(argp1);
37909 {
37910 PyThreadState* __tstate = wxPyBeginAllowThreads();
37911 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37912 wxPyEndAllowThreads(__tstate);
37913 if (PyErr_Occurred()) SWIG_fail;
37914 }
37915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37916 return resultobj;
37917 fail:
37918 return NULL;
37919 }
37920
37921
37922 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37923 PyObject *resultobj = 0;
37924 wxWindow *arg1 = (wxWindow *) 0 ;
37925 bool arg2 ;
37926 void *argp1 = 0 ;
37927 int res1 = 0 ;
37928 bool val2 ;
37929 int ecode2 = 0 ;
37930 PyObject * obj0 = 0 ;
37931 PyObject * obj1 = 0 ;
37932 char * kwnames[] = {
37933 (char *) "self",(char *) "autoLayout", NULL
37934 };
37935
37936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37938 if (!SWIG_IsOK(res1)) {
37939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37940 }
37941 arg1 = reinterpret_cast< wxWindow * >(argp1);
37942 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37943 if (!SWIG_IsOK(ecode2)) {
37944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37945 }
37946 arg2 = static_cast< bool >(val2);
37947 {
37948 PyThreadState* __tstate = wxPyBeginAllowThreads();
37949 (arg1)->SetAutoLayout(arg2);
37950 wxPyEndAllowThreads(__tstate);
37951 if (PyErr_Occurred()) SWIG_fail;
37952 }
37953 resultobj = SWIG_Py_Void();
37954 return resultobj;
37955 fail:
37956 return NULL;
37957 }
37958
37959
37960 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37961 PyObject *resultobj = 0;
37962 wxWindow *arg1 = (wxWindow *) 0 ;
37963 bool result;
37964 void *argp1 = 0 ;
37965 int res1 = 0 ;
37966 PyObject *swig_obj[1] ;
37967
37968 if (!args) SWIG_fail;
37969 swig_obj[0] = args;
37970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37971 if (!SWIG_IsOK(res1)) {
37972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37973 }
37974 arg1 = reinterpret_cast< wxWindow * >(argp1);
37975 {
37976 PyThreadState* __tstate = wxPyBeginAllowThreads();
37977 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37978 wxPyEndAllowThreads(__tstate);
37979 if (PyErr_Occurred()) SWIG_fail;
37980 }
37981 {
37982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37983 }
37984 return resultobj;
37985 fail:
37986 return NULL;
37987 }
37988
37989
37990 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37991 PyObject *resultobj = 0;
37992 wxWindow *arg1 = (wxWindow *) 0 ;
37993 bool result;
37994 void *argp1 = 0 ;
37995 int res1 = 0 ;
37996 PyObject *swig_obj[1] ;
37997
37998 if (!args) SWIG_fail;
37999 swig_obj[0] = args;
38000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38001 if (!SWIG_IsOK(res1)) {
38002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38003 }
38004 arg1 = reinterpret_cast< wxWindow * >(argp1);
38005 {
38006 PyThreadState* __tstate = wxPyBeginAllowThreads();
38007 result = (bool)(arg1)->Layout();
38008 wxPyEndAllowThreads(__tstate);
38009 if (PyErr_Occurred()) SWIG_fail;
38010 }
38011 {
38012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38013 }
38014 return resultobj;
38015 fail:
38016 return NULL;
38017 }
38018
38019
38020 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38021 PyObject *resultobj = 0;
38022 wxWindow *arg1 = (wxWindow *) 0 ;
38023 wxSizer *arg2 = (wxSizer *) 0 ;
38024 bool arg3 = (bool) true ;
38025 void *argp1 = 0 ;
38026 int res1 = 0 ;
38027 int res2 = 0 ;
38028 bool val3 ;
38029 int ecode3 = 0 ;
38030 PyObject * obj0 = 0 ;
38031 PyObject * obj1 = 0 ;
38032 PyObject * obj2 = 0 ;
38033 char * kwnames[] = {
38034 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38035 };
38036
38037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38039 if (!SWIG_IsOK(res1)) {
38040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38041 }
38042 arg1 = reinterpret_cast< wxWindow * >(argp1);
38043 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38044 if (!SWIG_IsOK(res2)) {
38045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38046 }
38047 if (obj2) {
38048 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38049 if (!SWIG_IsOK(ecode3)) {
38050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38051 }
38052 arg3 = static_cast< bool >(val3);
38053 }
38054 {
38055 PyThreadState* __tstate = wxPyBeginAllowThreads();
38056 (arg1)->SetSizer(arg2,arg3);
38057 wxPyEndAllowThreads(__tstate);
38058 if (PyErr_Occurred()) SWIG_fail;
38059 }
38060 resultobj = SWIG_Py_Void();
38061 return resultobj;
38062 fail:
38063 return NULL;
38064 }
38065
38066
38067 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38068 PyObject *resultobj = 0;
38069 wxWindow *arg1 = (wxWindow *) 0 ;
38070 wxSizer *arg2 = (wxSizer *) 0 ;
38071 bool arg3 = (bool) true ;
38072 void *argp1 = 0 ;
38073 int res1 = 0 ;
38074 int res2 = 0 ;
38075 bool val3 ;
38076 int ecode3 = 0 ;
38077 PyObject * obj0 = 0 ;
38078 PyObject * obj1 = 0 ;
38079 PyObject * obj2 = 0 ;
38080 char * kwnames[] = {
38081 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38082 };
38083
38084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38086 if (!SWIG_IsOK(res1)) {
38087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38088 }
38089 arg1 = reinterpret_cast< wxWindow * >(argp1);
38090 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38091 if (!SWIG_IsOK(res2)) {
38092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38093 }
38094 if (obj2) {
38095 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38096 if (!SWIG_IsOK(ecode3)) {
38097 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38098 }
38099 arg3 = static_cast< bool >(val3);
38100 }
38101 {
38102 PyThreadState* __tstate = wxPyBeginAllowThreads();
38103 (arg1)->SetSizerAndFit(arg2,arg3);
38104 wxPyEndAllowThreads(__tstate);
38105 if (PyErr_Occurred()) SWIG_fail;
38106 }
38107 resultobj = SWIG_Py_Void();
38108 return resultobj;
38109 fail:
38110 return NULL;
38111 }
38112
38113
38114 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38115 PyObject *resultobj = 0;
38116 wxWindow *arg1 = (wxWindow *) 0 ;
38117 wxSizer *result = 0 ;
38118 void *argp1 = 0 ;
38119 int res1 = 0 ;
38120 PyObject *swig_obj[1] ;
38121
38122 if (!args) SWIG_fail;
38123 swig_obj[0] = args;
38124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38125 if (!SWIG_IsOK(res1)) {
38126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38127 }
38128 arg1 = reinterpret_cast< wxWindow * >(argp1);
38129 {
38130 PyThreadState* __tstate = wxPyBeginAllowThreads();
38131 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38132 wxPyEndAllowThreads(__tstate);
38133 if (PyErr_Occurred()) SWIG_fail;
38134 }
38135 {
38136 resultobj = wxPyMake_wxObject(result, (bool)0);
38137 }
38138 return resultobj;
38139 fail:
38140 return NULL;
38141 }
38142
38143
38144 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38145 PyObject *resultobj = 0;
38146 wxWindow *arg1 = (wxWindow *) 0 ;
38147 wxSizer *arg2 = (wxSizer *) 0 ;
38148 void *argp1 = 0 ;
38149 int res1 = 0 ;
38150 void *argp2 = 0 ;
38151 int res2 = 0 ;
38152 PyObject * obj0 = 0 ;
38153 PyObject * obj1 = 0 ;
38154 char * kwnames[] = {
38155 (char *) "self",(char *) "sizer", NULL
38156 };
38157
38158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38160 if (!SWIG_IsOK(res1)) {
38161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38162 }
38163 arg1 = reinterpret_cast< wxWindow * >(argp1);
38164 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38165 if (!SWIG_IsOK(res2)) {
38166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38167 }
38168 arg2 = reinterpret_cast< wxSizer * >(argp2);
38169 {
38170 PyThreadState* __tstate = wxPyBeginAllowThreads();
38171 (arg1)->SetContainingSizer(arg2);
38172 wxPyEndAllowThreads(__tstate);
38173 if (PyErr_Occurred()) SWIG_fail;
38174 }
38175 resultobj = SWIG_Py_Void();
38176 return resultobj;
38177 fail:
38178 return NULL;
38179 }
38180
38181
38182 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38183 PyObject *resultobj = 0;
38184 wxWindow *arg1 = (wxWindow *) 0 ;
38185 wxSizer *result = 0 ;
38186 void *argp1 = 0 ;
38187 int res1 = 0 ;
38188 PyObject *swig_obj[1] ;
38189
38190 if (!args) SWIG_fail;
38191 swig_obj[0] = args;
38192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38193 if (!SWIG_IsOK(res1)) {
38194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38195 }
38196 arg1 = reinterpret_cast< wxWindow * >(argp1);
38197 {
38198 PyThreadState* __tstate = wxPyBeginAllowThreads();
38199 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38200 wxPyEndAllowThreads(__tstate);
38201 if (PyErr_Occurred()) SWIG_fail;
38202 }
38203 {
38204 resultobj = wxPyMake_wxObject(result, (bool)0);
38205 }
38206 return resultobj;
38207 fail:
38208 return NULL;
38209 }
38210
38211
38212 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38213 PyObject *resultobj = 0;
38214 wxWindow *arg1 = (wxWindow *) 0 ;
38215 void *argp1 = 0 ;
38216 int res1 = 0 ;
38217 PyObject *swig_obj[1] ;
38218
38219 if (!args) SWIG_fail;
38220 swig_obj[0] = args;
38221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38222 if (!SWIG_IsOK(res1)) {
38223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38224 }
38225 arg1 = reinterpret_cast< wxWindow * >(argp1);
38226 {
38227 PyThreadState* __tstate = wxPyBeginAllowThreads();
38228 (arg1)->InheritAttributes();
38229 wxPyEndAllowThreads(__tstate);
38230 if (PyErr_Occurred()) SWIG_fail;
38231 }
38232 resultobj = SWIG_Py_Void();
38233 return resultobj;
38234 fail:
38235 return NULL;
38236 }
38237
38238
38239 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38240 PyObject *resultobj = 0;
38241 wxWindow *arg1 = (wxWindow *) 0 ;
38242 bool result;
38243 void *argp1 = 0 ;
38244 int res1 = 0 ;
38245 PyObject *swig_obj[1] ;
38246
38247 if (!args) SWIG_fail;
38248 swig_obj[0] = args;
38249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38250 if (!SWIG_IsOK(res1)) {
38251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38252 }
38253 arg1 = reinterpret_cast< wxWindow * >(argp1);
38254 {
38255 PyThreadState* __tstate = wxPyBeginAllowThreads();
38256 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38257 wxPyEndAllowThreads(__tstate);
38258 if (PyErr_Occurred()) SWIG_fail;
38259 }
38260 {
38261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38262 }
38263 return resultobj;
38264 fail:
38265 return NULL;
38266 }
38267
38268
38269 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38270 PyObject *resultobj = 0;
38271 wxWindow *arg1 = (wxWindow *) 0 ;
38272 bool result;
38273 void *argp1 = 0 ;
38274 int res1 = 0 ;
38275 PyObject *swig_obj[1] ;
38276
38277 if (!args) SWIG_fail;
38278 swig_obj[0] = args;
38279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38280 if (!SWIG_IsOK(res1)) {
38281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38282 }
38283 arg1 = reinterpret_cast< wxWindow * >(argp1);
38284 {
38285 PyThreadState* __tstate = wxPyBeginAllowThreads();
38286 result = (bool)(arg1)->CanSetTransparent();
38287 wxPyEndAllowThreads(__tstate);
38288 if (PyErr_Occurred()) SWIG_fail;
38289 }
38290 {
38291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38292 }
38293 return resultobj;
38294 fail:
38295 return NULL;
38296 }
38297
38298
38299 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38300 PyObject *resultobj = 0;
38301 wxWindow *arg1 = (wxWindow *) 0 ;
38302 byte arg2 ;
38303 bool result;
38304 void *argp1 = 0 ;
38305 int res1 = 0 ;
38306 unsigned char val2 ;
38307 int ecode2 = 0 ;
38308 PyObject * obj0 = 0 ;
38309 PyObject * obj1 = 0 ;
38310 char * kwnames[] = {
38311 (char *) "self",(char *) "alpha", NULL
38312 };
38313
38314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38316 if (!SWIG_IsOK(res1)) {
38317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38318 }
38319 arg1 = reinterpret_cast< wxWindow * >(argp1);
38320 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38321 if (!SWIG_IsOK(ecode2)) {
38322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38323 }
38324 arg2 = static_cast< byte >(val2);
38325 {
38326 PyThreadState* __tstate = wxPyBeginAllowThreads();
38327 result = (bool)(arg1)->SetTransparent(arg2);
38328 wxPyEndAllowThreads(__tstate);
38329 if (PyErr_Occurred()) SWIG_fail;
38330 }
38331 {
38332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38333 }
38334 return resultobj;
38335 fail:
38336 return NULL;
38337 }
38338
38339
38340 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38341 PyObject *obj;
38342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38343 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38344 return SWIG_Py_Void();
38345 }
38346
38347 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38348 return SWIG_Python_InitShadowInstance(args);
38349 }
38350
38351 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38352 PyObject *resultobj = 0;
38353 long arg1 ;
38354 wxWindow *arg2 = (wxWindow *) NULL ;
38355 wxWindow *result = 0 ;
38356 long val1 ;
38357 int ecode1 = 0 ;
38358 void *argp2 = 0 ;
38359 int res2 = 0 ;
38360 PyObject * obj0 = 0 ;
38361 PyObject * obj1 = 0 ;
38362 char * kwnames[] = {
38363 (char *) "id",(char *) "parent", NULL
38364 };
38365
38366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38367 ecode1 = SWIG_AsVal_long(obj0, &val1);
38368 if (!SWIG_IsOK(ecode1)) {
38369 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38370 }
38371 arg1 = static_cast< long >(val1);
38372 if (obj1) {
38373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38374 if (!SWIG_IsOK(res2)) {
38375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38376 }
38377 arg2 = reinterpret_cast< wxWindow * >(argp2);
38378 }
38379 {
38380 if (!wxPyCheckForApp()) SWIG_fail;
38381 PyThreadState* __tstate = wxPyBeginAllowThreads();
38382 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38383 wxPyEndAllowThreads(__tstate);
38384 if (PyErr_Occurred()) SWIG_fail;
38385 }
38386 {
38387 resultobj = wxPyMake_wxObject(result, 0);
38388 }
38389 return resultobj;
38390 fail:
38391 return NULL;
38392 }
38393
38394
38395 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38396 PyObject *resultobj = 0;
38397 wxString *arg1 = 0 ;
38398 wxWindow *arg2 = (wxWindow *) NULL ;
38399 wxWindow *result = 0 ;
38400 bool temp1 = false ;
38401 void *argp2 = 0 ;
38402 int res2 = 0 ;
38403 PyObject * obj0 = 0 ;
38404 PyObject * obj1 = 0 ;
38405 char * kwnames[] = {
38406 (char *) "name",(char *) "parent", NULL
38407 };
38408
38409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38410 {
38411 arg1 = wxString_in_helper(obj0);
38412 if (arg1 == NULL) SWIG_fail;
38413 temp1 = true;
38414 }
38415 if (obj1) {
38416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38417 if (!SWIG_IsOK(res2)) {
38418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38419 }
38420 arg2 = reinterpret_cast< wxWindow * >(argp2);
38421 }
38422 {
38423 if (!wxPyCheckForApp()) SWIG_fail;
38424 PyThreadState* __tstate = wxPyBeginAllowThreads();
38425 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38426 wxPyEndAllowThreads(__tstate);
38427 if (PyErr_Occurred()) SWIG_fail;
38428 }
38429 {
38430 resultobj = wxPyMake_wxObject(result, 0);
38431 }
38432 {
38433 if (temp1)
38434 delete arg1;
38435 }
38436 return resultobj;
38437 fail:
38438 {
38439 if (temp1)
38440 delete arg1;
38441 }
38442 return NULL;
38443 }
38444
38445
38446 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38447 PyObject *resultobj = 0;
38448 wxString *arg1 = 0 ;
38449 wxWindow *arg2 = (wxWindow *) NULL ;
38450 wxWindow *result = 0 ;
38451 bool temp1 = false ;
38452 void *argp2 = 0 ;
38453 int res2 = 0 ;
38454 PyObject * obj0 = 0 ;
38455 PyObject * obj1 = 0 ;
38456 char * kwnames[] = {
38457 (char *) "label",(char *) "parent", NULL
38458 };
38459
38460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38461 {
38462 arg1 = wxString_in_helper(obj0);
38463 if (arg1 == NULL) SWIG_fail;
38464 temp1 = true;
38465 }
38466 if (obj1) {
38467 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38468 if (!SWIG_IsOK(res2)) {
38469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38470 }
38471 arg2 = reinterpret_cast< wxWindow * >(argp2);
38472 }
38473 {
38474 if (!wxPyCheckForApp()) SWIG_fail;
38475 PyThreadState* __tstate = wxPyBeginAllowThreads();
38476 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38477 wxPyEndAllowThreads(__tstate);
38478 if (PyErr_Occurred()) SWIG_fail;
38479 }
38480 {
38481 resultobj = wxPyMake_wxObject(result, 0);
38482 }
38483 {
38484 if (temp1)
38485 delete arg1;
38486 }
38487 return resultobj;
38488 fail:
38489 {
38490 if (temp1)
38491 delete arg1;
38492 }
38493 return NULL;
38494 }
38495
38496
38497 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38498 PyObject *resultobj = 0;
38499 wxWindow *arg1 = (wxWindow *) 0 ;
38500 unsigned long arg2 ;
38501 wxWindow *result = 0 ;
38502 void *argp1 = 0 ;
38503 int res1 = 0 ;
38504 unsigned long val2 ;
38505 int ecode2 = 0 ;
38506 PyObject * obj0 = 0 ;
38507 PyObject * obj1 = 0 ;
38508 char * kwnames[] = {
38509 (char *) "parent",(char *) "_hWnd", NULL
38510 };
38511
38512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38514 if (!SWIG_IsOK(res1)) {
38515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38516 }
38517 arg1 = reinterpret_cast< wxWindow * >(argp1);
38518 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38519 if (!SWIG_IsOK(ecode2)) {
38520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38521 }
38522 arg2 = static_cast< unsigned long >(val2);
38523 {
38524 PyThreadState* __tstate = wxPyBeginAllowThreads();
38525 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38526 wxPyEndAllowThreads(__tstate);
38527 if (PyErr_Occurred()) SWIG_fail;
38528 }
38529 {
38530 resultobj = wxPyMake_wxObject(result, 0);
38531 }
38532 return resultobj;
38533 fail:
38534 return NULL;
38535 }
38536
38537
38538 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38539 PyObject *resultobj = 0;
38540 PyObject *result = 0 ;
38541
38542 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38543 {
38544 PyThreadState* __tstate = wxPyBeginAllowThreads();
38545 result = (PyObject *)GetTopLevelWindows();
38546 wxPyEndAllowThreads(__tstate);
38547 if (PyErr_Occurred()) SWIG_fail;
38548 }
38549 resultobj = result;
38550 return resultobj;
38551 fail:
38552 return NULL;
38553 }
38554
38555
38556 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38557 PyObject *resultobj = 0;
38558 wxValidator *result = 0 ;
38559
38560 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38561 {
38562 PyThreadState* __tstate = wxPyBeginAllowThreads();
38563 result = (wxValidator *)new wxValidator();
38564 wxPyEndAllowThreads(__tstate);
38565 if (PyErr_Occurred()) SWIG_fail;
38566 }
38567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38568 return resultobj;
38569 fail:
38570 return NULL;
38571 }
38572
38573
38574 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38575 PyObject *resultobj = 0;
38576 wxValidator *arg1 = (wxValidator *) 0 ;
38577 wxValidator *result = 0 ;
38578 void *argp1 = 0 ;
38579 int res1 = 0 ;
38580 PyObject *swig_obj[1] ;
38581
38582 if (!args) SWIG_fail;
38583 swig_obj[0] = args;
38584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38585 if (!SWIG_IsOK(res1)) {
38586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38587 }
38588 arg1 = reinterpret_cast< wxValidator * >(argp1);
38589 {
38590 PyThreadState* __tstate = wxPyBeginAllowThreads();
38591 result = (wxValidator *)(arg1)->Clone();
38592 wxPyEndAllowThreads(__tstate);
38593 if (PyErr_Occurred()) SWIG_fail;
38594 }
38595 {
38596 resultobj = wxPyMake_wxObject(result, 0);
38597 }
38598 return resultobj;
38599 fail:
38600 return NULL;
38601 }
38602
38603
38604 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38605 PyObject *resultobj = 0;
38606 wxValidator *arg1 = (wxValidator *) 0 ;
38607 wxWindow *arg2 = (wxWindow *) 0 ;
38608 bool result;
38609 void *argp1 = 0 ;
38610 int res1 = 0 ;
38611 void *argp2 = 0 ;
38612 int res2 = 0 ;
38613 PyObject * obj0 = 0 ;
38614 PyObject * obj1 = 0 ;
38615 char * kwnames[] = {
38616 (char *) "self",(char *) "parent", NULL
38617 };
38618
38619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38621 if (!SWIG_IsOK(res1)) {
38622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38623 }
38624 arg1 = reinterpret_cast< wxValidator * >(argp1);
38625 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38626 if (!SWIG_IsOK(res2)) {
38627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38628 }
38629 arg2 = reinterpret_cast< wxWindow * >(argp2);
38630 {
38631 PyThreadState* __tstate = wxPyBeginAllowThreads();
38632 result = (bool)(arg1)->Validate(arg2);
38633 wxPyEndAllowThreads(__tstate);
38634 if (PyErr_Occurred()) SWIG_fail;
38635 }
38636 {
38637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38638 }
38639 return resultobj;
38640 fail:
38641 return NULL;
38642 }
38643
38644
38645 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38646 PyObject *resultobj = 0;
38647 wxValidator *arg1 = (wxValidator *) 0 ;
38648 bool result;
38649 void *argp1 = 0 ;
38650 int res1 = 0 ;
38651 PyObject *swig_obj[1] ;
38652
38653 if (!args) SWIG_fail;
38654 swig_obj[0] = args;
38655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38656 if (!SWIG_IsOK(res1)) {
38657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38658 }
38659 arg1 = reinterpret_cast< wxValidator * >(argp1);
38660 {
38661 PyThreadState* __tstate = wxPyBeginAllowThreads();
38662 result = (bool)(arg1)->TransferToWindow();
38663 wxPyEndAllowThreads(__tstate);
38664 if (PyErr_Occurred()) SWIG_fail;
38665 }
38666 {
38667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38668 }
38669 return resultobj;
38670 fail:
38671 return NULL;
38672 }
38673
38674
38675 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38676 PyObject *resultobj = 0;
38677 wxValidator *arg1 = (wxValidator *) 0 ;
38678 bool result;
38679 void *argp1 = 0 ;
38680 int res1 = 0 ;
38681 PyObject *swig_obj[1] ;
38682
38683 if (!args) SWIG_fail;
38684 swig_obj[0] = args;
38685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38686 if (!SWIG_IsOK(res1)) {
38687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38688 }
38689 arg1 = reinterpret_cast< wxValidator * >(argp1);
38690 {
38691 PyThreadState* __tstate = wxPyBeginAllowThreads();
38692 result = (bool)(arg1)->TransferFromWindow();
38693 wxPyEndAllowThreads(__tstate);
38694 if (PyErr_Occurred()) SWIG_fail;
38695 }
38696 {
38697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38698 }
38699 return resultobj;
38700 fail:
38701 return NULL;
38702 }
38703
38704
38705 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38706 PyObject *resultobj = 0;
38707 wxValidator *arg1 = (wxValidator *) 0 ;
38708 wxWindow *result = 0 ;
38709 void *argp1 = 0 ;
38710 int res1 = 0 ;
38711 PyObject *swig_obj[1] ;
38712
38713 if (!args) SWIG_fail;
38714 swig_obj[0] = args;
38715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38716 if (!SWIG_IsOK(res1)) {
38717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38718 }
38719 arg1 = reinterpret_cast< wxValidator * >(argp1);
38720 {
38721 PyThreadState* __tstate = wxPyBeginAllowThreads();
38722 result = (wxWindow *)(arg1)->GetWindow();
38723 wxPyEndAllowThreads(__tstate);
38724 if (PyErr_Occurred()) SWIG_fail;
38725 }
38726 {
38727 resultobj = wxPyMake_wxObject(result, 0);
38728 }
38729 return resultobj;
38730 fail:
38731 return NULL;
38732 }
38733
38734
38735 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38736 PyObject *resultobj = 0;
38737 wxValidator *arg1 = (wxValidator *) 0 ;
38738 wxWindow *arg2 = (wxWindow *) 0 ;
38739 void *argp1 = 0 ;
38740 int res1 = 0 ;
38741 void *argp2 = 0 ;
38742 int res2 = 0 ;
38743 PyObject * obj0 = 0 ;
38744 PyObject * obj1 = 0 ;
38745 char * kwnames[] = {
38746 (char *) "self",(char *) "window", NULL
38747 };
38748
38749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38751 if (!SWIG_IsOK(res1)) {
38752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38753 }
38754 arg1 = reinterpret_cast< wxValidator * >(argp1);
38755 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38756 if (!SWIG_IsOK(res2)) {
38757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38758 }
38759 arg2 = reinterpret_cast< wxWindow * >(argp2);
38760 {
38761 PyThreadState* __tstate = wxPyBeginAllowThreads();
38762 (arg1)->SetWindow(arg2);
38763 wxPyEndAllowThreads(__tstate);
38764 if (PyErr_Occurred()) SWIG_fail;
38765 }
38766 resultobj = SWIG_Py_Void();
38767 return resultobj;
38768 fail:
38769 return NULL;
38770 }
38771
38772
38773 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38774 PyObject *resultobj = 0;
38775 bool result;
38776
38777 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38778 {
38779 PyThreadState* __tstate = wxPyBeginAllowThreads();
38780 result = (bool)wxValidator::IsSilent();
38781 wxPyEndAllowThreads(__tstate);
38782 if (PyErr_Occurred()) SWIG_fail;
38783 }
38784 {
38785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38786 }
38787 return resultobj;
38788 fail:
38789 return NULL;
38790 }
38791
38792
38793 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38794 PyObject *resultobj = 0;
38795 int arg1 = (int) true ;
38796 int val1 ;
38797 int ecode1 = 0 ;
38798 PyObject * obj0 = 0 ;
38799 char * kwnames[] = {
38800 (char *) "doIt", NULL
38801 };
38802
38803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38804 if (obj0) {
38805 ecode1 = SWIG_AsVal_int(obj0, &val1);
38806 if (!SWIG_IsOK(ecode1)) {
38807 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38808 }
38809 arg1 = static_cast< int >(val1);
38810 }
38811 {
38812 PyThreadState* __tstate = wxPyBeginAllowThreads();
38813 wxValidator::SetBellOnError(arg1);
38814 wxPyEndAllowThreads(__tstate);
38815 if (PyErr_Occurred()) SWIG_fail;
38816 }
38817 resultobj = SWIG_Py_Void();
38818 return resultobj;
38819 fail:
38820 return NULL;
38821 }
38822
38823
38824 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38825 PyObject *obj;
38826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38827 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38828 return SWIG_Py_Void();
38829 }
38830
38831 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38832 return SWIG_Python_InitShadowInstance(args);
38833 }
38834
38835 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38836 PyObject *resultobj = 0;
38837 wxPyValidator *result = 0 ;
38838
38839 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38840 {
38841 PyThreadState* __tstate = wxPyBeginAllowThreads();
38842 result = (wxPyValidator *)new wxPyValidator();
38843 wxPyEndAllowThreads(__tstate);
38844 if (PyErr_Occurred()) SWIG_fail;
38845 }
38846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38847 return resultobj;
38848 fail:
38849 return NULL;
38850 }
38851
38852
38853 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38854 PyObject *resultobj = 0;
38855 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38856 PyObject *arg2 = (PyObject *) 0 ;
38857 PyObject *arg3 = (PyObject *) 0 ;
38858 int arg4 = (int) true ;
38859 void *argp1 = 0 ;
38860 int res1 = 0 ;
38861 int val4 ;
38862 int ecode4 = 0 ;
38863 PyObject * obj0 = 0 ;
38864 PyObject * obj1 = 0 ;
38865 PyObject * obj2 = 0 ;
38866 PyObject * obj3 = 0 ;
38867 char * kwnames[] = {
38868 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38869 };
38870
38871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38873 if (!SWIG_IsOK(res1)) {
38874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38875 }
38876 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38877 arg2 = obj1;
38878 arg3 = obj2;
38879 if (obj3) {
38880 ecode4 = SWIG_AsVal_int(obj3, &val4);
38881 if (!SWIG_IsOK(ecode4)) {
38882 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38883 }
38884 arg4 = static_cast< int >(val4);
38885 }
38886 {
38887 PyThreadState* __tstate = wxPyBeginAllowThreads();
38888 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38889 wxPyEndAllowThreads(__tstate);
38890 if (PyErr_Occurred()) SWIG_fail;
38891 }
38892 resultobj = SWIG_Py_Void();
38893 return resultobj;
38894 fail:
38895 return NULL;
38896 }
38897
38898
38899 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38900 PyObject *obj;
38901 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38902 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38903 return SWIG_Py_Void();
38904 }
38905
38906 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38907 return SWIG_Python_InitShadowInstance(args);
38908 }
38909
38910 SWIGINTERN int DefaultValidator_set(PyObject *) {
38911 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38912 return 1;
38913 }
38914
38915
38916 SWIGINTERN PyObject *DefaultValidator_get(void) {
38917 PyObject *pyobj = 0;
38918
38919 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38920 return pyobj;
38921 }
38922
38923
38924 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38925 PyObject *resultobj = 0;
38926 wxString const &arg1_defvalue = wxPyEmptyString ;
38927 wxString *arg1 = (wxString *) &arg1_defvalue ;
38928 long arg2 = (long) 0 ;
38929 wxMenu *result = 0 ;
38930 bool temp1 = false ;
38931 long val2 ;
38932 int ecode2 = 0 ;
38933 PyObject * obj0 = 0 ;
38934 PyObject * obj1 = 0 ;
38935 char * kwnames[] = {
38936 (char *) "title",(char *) "style", NULL
38937 };
38938
38939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38940 if (obj0) {
38941 {
38942 arg1 = wxString_in_helper(obj0);
38943 if (arg1 == NULL) SWIG_fail;
38944 temp1 = true;
38945 }
38946 }
38947 if (obj1) {
38948 ecode2 = SWIG_AsVal_long(obj1, &val2);
38949 if (!SWIG_IsOK(ecode2)) {
38950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38951 }
38952 arg2 = static_cast< long >(val2);
38953 }
38954 {
38955 if (!wxPyCheckForApp()) SWIG_fail;
38956 PyThreadState* __tstate = wxPyBeginAllowThreads();
38957 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38958 wxPyEndAllowThreads(__tstate);
38959 if (PyErr_Occurred()) SWIG_fail;
38960 }
38961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38962 {
38963 if (temp1)
38964 delete arg1;
38965 }
38966 return resultobj;
38967 fail:
38968 {
38969 if (temp1)
38970 delete arg1;
38971 }
38972 return NULL;
38973 }
38974
38975
38976 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38977 PyObject *resultobj = 0;
38978 wxMenu *arg1 = (wxMenu *) 0 ;
38979 int arg2 ;
38980 wxString const &arg3_defvalue = wxPyEmptyString ;
38981 wxString *arg3 = (wxString *) &arg3_defvalue ;
38982 wxString const &arg4_defvalue = wxPyEmptyString ;
38983 wxString *arg4 = (wxString *) &arg4_defvalue ;
38984 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38985 wxMenuItem *result = 0 ;
38986 void *argp1 = 0 ;
38987 int res1 = 0 ;
38988 int val2 ;
38989 int ecode2 = 0 ;
38990 bool temp3 = false ;
38991 bool temp4 = false ;
38992 int val5 ;
38993 int ecode5 = 0 ;
38994 PyObject * obj0 = 0 ;
38995 PyObject * obj1 = 0 ;
38996 PyObject * obj2 = 0 ;
38997 PyObject * obj3 = 0 ;
38998 PyObject * obj4 = 0 ;
38999 char * kwnames[] = {
39000 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39001 };
39002
39003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39005 if (!SWIG_IsOK(res1)) {
39006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39007 }
39008 arg1 = reinterpret_cast< wxMenu * >(argp1);
39009 ecode2 = SWIG_AsVal_int(obj1, &val2);
39010 if (!SWIG_IsOK(ecode2)) {
39011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39012 }
39013 arg2 = static_cast< int >(val2);
39014 if (obj2) {
39015 {
39016 arg3 = wxString_in_helper(obj2);
39017 if (arg3 == NULL) SWIG_fail;
39018 temp3 = true;
39019 }
39020 }
39021 if (obj3) {
39022 {
39023 arg4 = wxString_in_helper(obj3);
39024 if (arg4 == NULL) SWIG_fail;
39025 temp4 = true;
39026 }
39027 }
39028 if (obj4) {
39029 ecode5 = SWIG_AsVal_int(obj4, &val5);
39030 if (!SWIG_IsOK(ecode5)) {
39031 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39032 }
39033 arg5 = static_cast< wxItemKind >(val5);
39034 }
39035 {
39036 PyThreadState* __tstate = wxPyBeginAllowThreads();
39037 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39038 wxPyEndAllowThreads(__tstate);
39039 if (PyErr_Occurred()) SWIG_fail;
39040 }
39041 {
39042 resultobj = wxPyMake_wxObject(result, (bool)0);
39043 }
39044 {
39045 if (temp3)
39046 delete arg3;
39047 }
39048 {
39049 if (temp4)
39050 delete arg4;
39051 }
39052 return resultobj;
39053 fail:
39054 {
39055 if (temp3)
39056 delete arg3;
39057 }
39058 {
39059 if (temp4)
39060 delete arg4;
39061 }
39062 return NULL;
39063 }
39064
39065
39066 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39067 PyObject *resultobj = 0;
39068 wxMenu *arg1 = (wxMenu *) 0 ;
39069 wxMenuItem *result = 0 ;
39070 void *argp1 = 0 ;
39071 int res1 = 0 ;
39072 PyObject *swig_obj[1] ;
39073
39074 if (!args) SWIG_fail;
39075 swig_obj[0] = args;
39076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39077 if (!SWIG_IsOK(res1)) {
39078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39079 }
39080 arg1 = reinterpret_cast< wxMenu * >(argp1);
39081 {
39082 PyThreadState* __tstate = wxPyBeginAllowThreads();
39083 result = (wxMenuItem *)(arg1)->AppendSeparator();
39084 wxPyEndAllowThreads(__tstate);
39085 if (PyErr_Occurred()) SWIG_fail;
39086 }
39087 {
39088 resultobj = wxPyMake_wxObject(result, (bool)0);
39089 }
39090 return resultobj;
39091 fail:
39092 return NULL;
39093 }
39094
39095
39096 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39097 PyObject *resultobj = 0;
39098 wxMenu *arg1 = (wxMenu *) 0 ;
39099 int arg2 ;
39100 wxString *arg3 = 0 ;
39101 wxString const &arg4_defvalue = wxPyEmptyString ;
39102 wxString *arg4 = (wxString *) &arg4_defvalue ;
39103 wxMenuItem *result = 0 ;
39104 void *argp1 = 0 ;
39105 int res1 = 0 ;
39106 int val2 ;
39107 int ecode2 = 0 ;
39108 bool temp3 = false ;
39109 bool temp4 = false ;
39110 PyObject * obj0 = 0 ;
39111 PyObject * obj1 = 0 ;
39112 PyObject * obj2 = 0 ;
39113 PyObject * obj3 = 0 ;
39114 char * kwnames[] = {
39115 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39116 };
39117
39118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39120 if (!SWIG_IsOK(res1)) {
39121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39122 }
39123 arg1 = reinterpret_cast< wxMenu * >(argp1);
39124 ecode2 = SWIG_AsVal_int(obj1, &val2);
39125 if (!SWIG_IsOK(ecode2)) {
39126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39127 }
39128 arg2 = static_cast< int >(val2);
39129 {
39130 arg3 = wxString_in_helper(obj2);
39131 if (arg3 == NULL) SWIG_fail;
39132 temp3 = true;
39133 }
39134 if (obj3) {
39135 {
39136 arg4 = wxString_in_helper(obj3);
39137 if (arg4 == NULL) SWIG_fail;
39138 temp4 = true;
39139 }
39140 }
39141 {
39142 PyThreadState* __tstate = wxPyBeginAllowThreads();
39143 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39144 wxPyEndAllowThreads(__tstate);
39145 if (PyErr_Occurred()) SWIG_fail;
39146 }
39147 {
39148 resultobj = wxPyMake_wxObject(result, (bool)0);
39149 }
39150 {
39151 if (temp3)
39152 delete arg3;
39153 }
39154 {
39155 if (temp4)
39156 delete arg4;
39157 }
39158 return resultobj;
39159 fail:
39160 {
39161 if (temp3)
39162 delete arg3;
39163 }
39164 {
39165 if (temp4)
39166 delete arg4;
39167 }
39168 return NULL;
39169 }
39170
39171
39172 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39173 PyObject *resultobj = 0;
39174 wxMenu *arg1 = (wxMenu *) 0 ;
39175 int arg2 ;
39176 wxString *arg3 = 0 ;
39177 wxString const &arg4_defvalue = wxPyEmptyString ;
39178 wxString *arg4 = (wxString *) &arg4_defvalue ;
39179 wxMenuItem *result = 0 ;
39180 void *argp1 = 0 ;
39181 int res1 = 0 ;
39182 int val2 ;
39183 int ecode2 = 0 ;
39184 bool temp3 = false ;
39185 bool temp4 = false ;
39186 PyObject * obj0 = 0 ;
39187 PyObject * obj1 = 0 ;
39188 PyObject * obj2 = 0 ;
39189 PyObject * obj3 = 0 ;
39190 char * kwnames[] = {
39191 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39192 };
39193
39194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39196 if (!SWIG_IsOK(res1)) {
39197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39198 }
39199 arg1 = reinterpret_cast< wxMenu * >(argp1);
39200 ecode2 = SWIG_AsVal_int(obj1, &val2);
39201 if (!SWIG_IsOK(ecode2)) {
39202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39203 }
39204 arg2 = static_cast< int >(val2);
39205 {
39206 arg3 = wxString_in_helper(obj2);
39207 if (arg3 == NULL) SWIG_fail;
39208 temp3 = true;
39209 }
39210 if (obj3) {
39211 {
39212 arg4 = wxString_in_helper(obj3);
39213 if (arg4 == NULL) SWIG_fail;
39214 temp4 = true;
39215 }
39216 }
39217 {
39218 PyThreadState* __tstate = wxPyBeginAllowThreads();
39219 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39220 wxPyEndAllowThreads(__tstate);
39221 if (PyErr_Occurred()) SWIG_fail;
39222 }
39223 {
39224 resultobj = wxPyMake_wxObject(result, (bool)0);
39225 }
39226 {
39227 if (temp3)
39228 delete arg3;
39229 }
39230 {
39231 if (temp4)
39232 delete arg4;
39233 }
39234 return resultobj;
39235 fail:
39236 {
39237 if (temp3)
39238 delete arg3;
39239 }
39240 {
39241 if (temp4)
39242 delete arg4;
39243 }
39244 return NULL;
39245 }
39246
39247
39248 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39249 PyObject *resultobj = 0;
39250 wxMenu *arg1 = (wxMenu *) 0 ;
39251 int arg2 ;
39252 wxString *arg3 = 0 ;
39253 wxMenu *arg4 = (wxMenu *) 0 ;
39254 wxString const &arg5_defvalue = wxPyEmptyString ;
39255 wxString *arg5 = (wxString *) &arg5_defvalue ;
39256 wxMenuItem *result = 0 ;
39257 void *argp1 = 0 ;
39258 int res1 = 0 ;
39259 int val2 ;
39260 int ecode2 = 0 ;
39261 bool temp3 = false ;
39262 void *argp4 = 0 ;
39263 int res4 = 0 ;
39264 bool temp5 = false ;
39265 PyObject * obj0 = 0 ;
39266 PyObject * obj1 = 0 ;
39267 PyObject * obj2 = 0 ;
39268 PyObject * obj3 = 0 ;
39269 PyObject * obj4 = 0 ;
39270 char * kwnames[] = {
39271 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39272 };
39273
39274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39276 if (!SWIG_IsOK(res1)) {
39277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39278 }
39279 arg1 = reinterpret_cast< wxMenu * >(argp1);
39280 ecode2 = SWIG_AsVal_int(obj1, &val2);
39281 if (!SWIG_IsOK(ecode2)) {
39282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39283 }
39284 arg2 = static_cast< int >(val2);
39285 {
39286 arg3 = wxString_in_helper(obj2);
39287 if (arg3 == NULL) SWIG_fail;
39288 temp3 = true;
39289 }
39290 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39291 if (!SWIG_IsOK(res4)) {
39292 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39293 }
39294 arg4 = reinterpret_cast< wxMenu * >(argp4);
39295 if (obj4) {
39296 {
39297 arg5 = wxString_in_helper(obj4);
39298 if (arg5 == NULL) SWIG_fail;
39299 temp5 = true;
39300 }
39301 }
39302 {
39303 PyThreadState* __tstate = wxPyBeginAllowThreads();
39304 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39305 wxPyEndAllowThreads(__tstate);
39306 if (PyErr_Occurred()) SWIG_fail;
39307 }
39308 {
39309 resultobj = wxPyMake_wxObject(result, (bool)0);
39310 }
39311 {
39312 if (temp3)
39313 delete arg3;
39314 }
39315 {
39316 if (temp5)
39317 delete arg5;
39318 }
39319 return resultobj;
39320 fail:
39321 {
39322 if (temp3)
39323 delete arg3;
39324 }
39325 {
39326 if (temp5)
39327 delete arg5;
39328 }
39329 return NULL;
39330 }
39331
39332
39333 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39334 PyObject *resultobj = 0;
39335 wxMenu *arg1 = (wxMenu *) 0 ;
39336 wxMenu *arg2 = (wxMenu *) 0 ;
39337 wxString *arg3 = 0 ;
39338 wxString const &arg4_defvalue = wxPyEmptyString ;
39339 wxString *arg4 = (wxString *) &arg4_defvalue ;
39340 wxMenuItem *result = 0 ;
39341 void *argp1 = 0 ;
39342 int res1 = 0 ;
39343 void *argp2 = 0 ;
39344 int res2 = 0 ;
39345 bool temp3 = false ;
39346 bool temp4 = false ;
39347 PyObject * obj0 = 0 ;
39348 PyObject * obj1 = 0 ;
39349 PyObject * obj2 = 0 ;
39350 PyObject * obj3 = 0 ;
39351 char * kwnames[] = {
39352 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39353 };
39354
39355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39357 if (!SWIG_IsOK(res1)) {
39358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39359 }
39360 arg1 = reinterpret_cast< wxMenu * >(argp1);
39361 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39362 if (!SWIG_IsOK(res2)) {
39363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39364 }
39365 arg2 = reinterpret_cast< wxMenu * >(argp2);
39366 {
39367 arg3 = wxString_in_helper(obj2);
39368 if (arg3 == NULL) SWIG_fail;
39369 temp3 = true;
39370 }
39371 if (obj3) {
39372 {
39373 arg4 = wxString_in_helper(obj3);
39374 if (arg4 == NULL) SWIG_fail;
39375 temp4 = true;
39376 }
39377 }
39378 {
39379 PyThreadState* __tstate = wxPyBeginAllowThreads();
39380 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39381 wxPyEndAllowThreads(__tstate);
39382 if (PyErr_Occurred()) SWIG_fail;
39383 }
39384 {
39385 resultobj = wxPyMake_wxObject(result, (bool)0);
39386 }
39387 {
39388 if (temp3)
39389 delete arg3;
39390 }
39391 {
39392 if (temp4)
39393 delete arg4;
39394 }
39395 return resultobj;
39396 fail:
39397 {
39398 if (temp3)
39399 delete arg3;
39400 }
39401 {
39402 if (temp4)
39403 delete arg4;
39404 }
39405 return NULL;
39406 }
39407
39408
39409 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39410 PyObject *resultobj = 0;
39411 wxMenu *arg1 = (wxMenu *) 0 ;
39412 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39413 wxMenuItem *result = 0 ;
39414 void *argp1 = 0 ;
39415 int res1 = 0 ;
39416 int res2 = 0 ;
39417 PyObject * obj0 = 0 ;
39418 PyObject * obj1 = 0 ;
39419 char * kwnames[] = {
39420 (char *) "self",(char *) "item", NULL
39421 };
39422
39423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39425 if (!SWIG_IsOK(res1)) {
39426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39427 }
39428 arg1 = reinterpret_cast< wxMenu * >(argp1);
39429 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39430 if (!SWIG_IsOK(res2)) {
39431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39432 }
39433 {
39434 PyThreadState* __tstate = wxPyBeginAllowThreads();
39435 result = (wxMenuItem *)(arg1)->Append(arg2);
39436 wxPyEndAllowThreads(__tstate);
39437 if (PyErr_Occurred()) SWIG_fail;
39438 }
39439 {
39440 resultobj = wxPyMake_wxObject(result, (bool)0);
39441 }
39442 return resultobj;
39443 fail:
39444 return NULL;
39445 }
39446
39447
39448 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39449 PyObject *resultobj = 0;
39450 wxMenu *arg1 = (wxMenu *) 0 ;
39451 size_t arg2 ;
39452 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39453 wxMenuItem *result = 0 ;
39454 void *argp1 = 0 ;
39455 int res1 = 0 ;
39456 size_t val2 ;
39457 int ecode2 = 0 ;
39458 int res3 = 0 ;
39459 PyObject * obj0 = 0 ;
39460 PyObject * obj1 = 0 ;
39461 PyObject * obj2 = 0 ;
39462 char * kwnames[] = {
39463 (char *) "self",(char *) "pos",(char *) "item", NULL
39464 };
39465
39466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39468 if (!SWIG_IsOK(res1)) {
39469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39470 }
39471 arg1 = reinterpret_cast< wxMenu * >(argp1);
39472 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39473 if (!SWIG_IsOK(ecode2)) {
39474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39475 }
39476 arg2 = static_cast< size_t >(val2);
39477 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39478 if (!SWIG_IsOK(res3)) {
39479 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39480 }
39481 {
39482 PyThreadState* __tstate = wxPyBeginAllowThreads();
39483 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39484 wxPyEndAllowThreads(__tstate);
39485 if (PyErr_Occurred()) SWIG_fail;
39486 }
39487 {
39488 resultobj = wxPyMake_wxObject(result, (bool)0);
39489 }
39490 return resultobj;
39491 fail:
39492 return NULL;
39493 }
39494
39495
39496 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39497 PyObject *resultobj = 0;
39498 wxMenu *arg1 = (wxMenu *) 0 ;
39499 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39500 wxMenuItem *result = 0 ;
39501 void *argp1 = 0 ;
39502 int res1 = 0 ;
39503 int res2 = 0 ;
39504 PyObject * obj0 = 0 ;
39505 PyObject * obj1 = 0 ;
39506 char * kwnames[] = {
39507 (char *) "self",(char *) "item", NULL
39508 };
39509
39510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39512 if (!SWIG_IsOK(res1)) {
39513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39514 }
39515 arg1 = reinterpret_cast< wxMenu * >(argp1);
39516 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39517 if (!SWIG_IsOK(res2)) {
39518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39519 }
39520 {
39521 PyThreadState* __tstate = wxPyBeginAllowThreads();
39522 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39523 wxPyEndAllowThreads(__tstate);
39524 if (PyErr_Occurred()) SWIG_fail;
39525 }
39526 {
39527 resultobj = wxPyMake_wxObject(result, (bool)0);
39528 }
39529 return resultobj;
39530 fail:
39531 return NULL;
39532 }
39533
39534
39535 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39536 PyObject *resultobj = 0;
39537 wxMenu *arg1 = (wxMenu *) 0 ;
39538 void *argp1 = 0 ;
39539 int res1 = 0 ;
39540 PyObject *swig_obj[1] ;
39541
39542 if (!args) SWIG_fail;
39543 swig_obj[0] = args;
39544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39545 if (!SWIG_IsOK(res1)) {
39546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39547 }
39548 arg1 = reinterpret_cast< wxMenu * >(argp1);
39549 {
39550 PyThreadState* __tstate = wxPyBeginAllowThreads();
39551 (arg1)->Break();
39552 wxPyEndAllowThreads(__tstate);
39553 if (PyErr_Occurred()) SWIG_fail;
39554 }
39555 resultobj = SWIG_Py_Void();
39556 return resultobj;
39557 fail:
39558 return NULL;
39559 }
39560
39561
39562 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39563 PyObject *resultobj = 0;
39564 wxMenu *arg1 = (wxMenu *) 0 ;
39565 size_t arg2 ;
39566 int arg3 ;
39567 wxString const &arg4_defvalue = wxPyEmptyString ;
39568 wxString *arg4 = (wxString *) &arg4_defvalue ;
39569 wxString const &arg5_defvalue = wxPyEmptyString ;
39570 wxString *arg5 = (wxString *) &arg5_defvalue ;
39571 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39572 wxMenuItem *result = 0 ;
39573 void *argp1 = 0 ;
39574 int res1 = 0 ;
39575 size_t val2 ;
39576 int ecode2 = 0 ;
39577 int val3 ;
39578 int ecode3 = 0 ;
39579 bool temp4 = false ;
39580 bool temp5 = false ;
39581 int val6 ;
39582 int ecode6 = 0 ;
39583 PyObject * obj0 = 0 ;
39584 PyObject * obj1 = 0 ;
39585 PyObject * obj2 = 0 ;
39586 PyObject * obj3 = 0 ;
39587 PyObject * obj4 = 0 ;
39588 PyObject * obj5 = 0 ;
39589 char * kwnames[] = {
39590 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39591 };
39592
39593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39595 if (!SWIG_IsOK(res1)) {
39596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39597 }
39598 arg1 = reinterpret_cast< wxMenu * >(argp1);
39599 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39600 if (!SWIG_IsOK(ecode2)) {
39601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39602 }
39603 arg2 = static_cast< size_t >(val2);
39604 ecode3 = SWIG_AsVal_int(obj2, &val3);
39605 if (!SWIG_IsOK(ecode3)) {
39606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39607 }
39608 arg3 = static_cast< int >(val3);
39609 if (obj3) {
39610 {
39611 arg4 = wxString_in_helper(obj3);
39612 if (arg4 == NULL) SWIG_fail;
39613 temp4 = true;
39614 }
39615 }
39616 if (obj4) {
39617 {
39618 arg5 = wxString_in_helper(obj4);
39619 if (arg5 == NULL) SWIG_fail;
39620 temp5 = true;
39621 }
39622 }
39623 if (obj5) {
39624 ecode6 = SWIG_AsVal_int(obj5, &val6);
39625 if (!SWIG_IsOK(ecode6)) {
39626 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39627 }
39628 arg6 = static_cast< wxItemKind >(val6);
39629 }
39630 {
39631 PyThreadState* __tstate = wxPyBeginAllowThreads();
39632 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39633 wxPyEndAllowThreads(__tstate);
39634 if (PyErr_Occurred()) SWIG_fail;
39635 }
39636 {
39637 resultobj = wxPyMake_wxObject(result, (bool)0);
39638 }
39639 {
39640 if (temp4)
39641 delete arg4;
39642 }
39643 {
39644 if (temp5)
39645 delete arg5;
39646 }
39647 return resultobj;
39648 fail:
39649 {
39650 if (temp4)
39651 delete arg4;
39652 }
39653 {
39654 if (temp5)
39655 delete arg5;
39656 }
39657 return NULL;
39658 }
39659
39660
39661 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39662 PyObject *resultobj = 0;
39663 wxMenu *arg1 = (wxMenu *) 0 ;
39664 size_t arg2 ;
39665 wxMenuItem *result = 0 ;
39666 void *argp1 = 0 ;
39667 int res1 = 0 ;
39668 size_t val2 ;
39669 int ecode2 = 0 ;
39670 PyObject * obj0 = 0 ;
39671 PyObject * obj1 = 0 ;
39672 char * kwnames[] = {
39673 (char *) "self",(char *) "pos", NULL
39674 };
39675
39676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39678 if (!SWIG_IsOK(res1)) {
39679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39680 }
39681 arg1 = reinterpret_cast< wxMenu * >(argp1);
39682 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39683 if (!SWIG_IsOK(ecode2)) {
39684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39685 }
39686 arg2 = static_cast< size_t >(val2);
39687 {
39688 PyThreadState* __tstate = wxPyBeginAllowThreads();
39689 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39690 wxPyEndAllowThreads(__tstate);
39691 if (PyErr_Occurred()) SWIG_fail;
39692 }
39693 {
39694 resultobj = wxPyMake_wxObject(result, (bool)0);
39695 }
39696 return resultobj;
39697 fail:
39698 return NULL;
39699 }
39700
39701
39702 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39703 PyObject *resultobj = 0;
39704 wxMenu *arg1 = (wxMenu *) 0 ;
39705 size_t arg2 ;
39706 int arg3 ;
39707 wxString *arg4 = 0 ;
39708 wxString const &arg5_defvalue = wxPyEmptyString ;
39709 wxString *arg5 = (wxString *) &arg5_defvalue ;
39710 wxMenuItem *result = 0 ;
39711 void *argp1 = 0 ;
39712 int res1 = 0 ;
39713 size_t val2 ;
39714 int ecode2 = 0 ;
39715 int val3 ;
39716 int ecode3 = 0 ;
39717 bool temp4 = false ;
39718 bool temp5 = false ;
39719 PyObject * obj0 = 0 ;
39720 PyObject * obj1 = 0 ;
39721 PyObject * obj2 = 0 ;
39722 PyObject * obj3 = 0 ;
39723 PyObject * obj4 = 0 ;
39724 char * kwnames[] = {
39725 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39726 };
39727
39728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39730 if (!SWIG_IsOK(res1)) {
39731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39732 }
39733 arg1 = reinterpret_cast< wxMenu * >(argp1);
39734 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39735 if (!SWIG_IsOK(ecode2)) {
39736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39737 }
39738 arg2 = static_cast< size_t >(val2);
39739 ecode3 = SWIG_AsVal_int(obj2, &val3);
39740 if (!SWIG_IsOK(ecode3)) {
39741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39742 }
39743 arg3 = static_cast< int >(val3);
39744 {
39745 arg4 = wxString_in_helper(obj3);
39746 if (arg4 == NULL) SWIG_fail;
39747 temp4 = true;
39748 }
39749 if (obj4) {
39750 {
39751 arg5 = wxString_in_helper(obj4);
39752 if (arg5 == NULL) SWIG_fail;
39753 temp5 = true;
39754 }
39755 }
39756 {
39757 PyThreadState* __tstate = wxPyBeginAllowThreads();
39758 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39759 wxPyEndAllowThreads(__tstate);
39760 if (PyErr_Occurred()) SWIG_fail;
39761 }
39762 {
39763 resultobj = wxPyMake_wxObject(result, (bool)0);
39764 }
39765 {
39766 if (temp4)
39767 delete arg4;
39768 }
39769 {
39770 if (temp5)
39771 delete arg5;
39772 }
39773 return resultobj;
39774 fail:
39775 {
39776 if (temp4)
39777 delete arg4;
39778 }
39779 {
39780 if (temp5)
39781 delete arg5;
39782 }
39783 return NULL;
39784 }
39785
39786
39787 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39788 PyObject *resultobj = 0;
39789 wxMenu *arg1 = (wxMenu *) 0 ;
39790 size_t arg2 ;
39791 int arg3 ;
39792 wxString *arg4 = 0 ;
39793 wxString const &arg5_defvalue = wxPyEmptyString ;
39794 wxString *arg5 = (wxString *) &arg5_defvalue ;
39795 wxMenuItem *result = 0 ;
39796 void *argp1 = 0 ;
39797 int res1 = 0 ;
39798 size_t val2 ;
39799 int ecode2 = 0 ;
39800 int val3 ;
39801 int ecode3 = 0 ;
39802 bool temp4 = false ;
39803 bool temp5 = false ;
39804 PyObject * obj0 = 0 ;
39805 PyObject * obj1 = 0 ;
39806 PyObject * obj2 = 0 ;
39807 PyObject * obj3 = 0 ;
39808 PyObject * obj4 = 0 ;
39809 char * kwnames[] = {
39810 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39811 };
39812
39813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39815 if (!SWIG_IsOK(res1)) {
39816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39817 }
39818 arg1 = reinterpret_cast< wxMenu * >(argp1);
39819 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39820 if (!SWIG_IsOK(ecode2)) {
39821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39822 }
39823 arg2 = static_cast< size_t >(val2);
39824 ecode3 = SWIG_AsVal_int(obj2, &val3);
39825 if (!SWIG_IsOK(ecode3)) {
39826 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39827 }
39828 arg3 = static_cast< int >(val3);
39829 {
39830 arg4 = wxString_in_helper(obj3);
39831 if (arg4 == NULL) SWIG_fail;
39832 temp4 = true;
39833 }
39834 if (obj4) {
39835 {
39836 arg5 = wxString_in_helper(obj4);
39837 if (arg5 == NULL) SWIG_fail;
39838 temp5 = true;
39839 }
39840 }
39841 {
39842 PyThreadState* __tstate = wxPyBeginAllowThreads();
39843 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39844 wxPyEndAllowThreads(__tstate);
39845 if (PyErr_Occurred()) SWIG_fail;
39846 }
39847 {
39848 resultobj = wxPyMake_wxObject(result, (bool)0);
39849 }
39850 {
39851 if (temp4)
39852 delete arg4;
39853 }
39854 {
39855 if (temp5)
39856 delete arg5;
39857 }
39858 return resultobj;
39859 fail:
39860 {
39861 if (temp4)
39862 delete arg4;
39863 }
39864 {
39865 if (temp5)
39866 delete arg5;
39867 }
39868 return NULL;
39869 }
39870
39871
39872 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39873 PyObject *resultobj = 0;
39874 wxMenu *arg1 = (wxMenu *) 0 ;
39875 size_t arg2 ;
39876 int arg3 ;
39877 wxString *arg4 = 0 ;
39878 wxMenu *arg5 = (wxMenu *) 0 ;
39879 wxString const &arg6_defvalue = wxPyEmptyString ;
39880 wxString *arg6 = (wxString *) &arg6_defvalue ;
39881 wxMenuItem *result = 0 ;
39882 void *argp1 = 0 ;
39883 int res1 = 0 ;
39884 size_t val2 ;
39885 int ecode2 = 0 ;
39886 int val3 ;
39887 int ecode3 = 0 ;
39888 bool temp4 = false ;
39889 void *argp5 = 0 ;
39890 int res5 = 0 ;
39891 bool temp6 = false ;
39892 PyObject * obj0 = 0 ;
39893 PyObject * obj1 = 0 ;
39894 PyObject * obj2 = 0 ;
39895 PyObject * obj3 = 0 ;
39896 PyObject * obj4 = 0 ;
39897 PyObject * obj5 = 0 ;
39898 char * kwnames[] = {
39899 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39900 };
39901
39902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39904 if (!SWIG_IsOK(res1)) {
39905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39906 }
39907 arg1 = reinterpret_cast< wxMenu * >(argp1);
39908 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39909 if (!SWIG_IsOK(ecode2)) {
39910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39911 }
39912 arg2 = static_cast< size_t >(val2);
39913 ecode3 = SWIG_AsVal_int(obj2, &val3);
39914 if (!SWIG_IsOK(ecode3)) {
39915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39916 }
39917 arg3 = static_cast< int >(val3);
39918 {
39919 arg4 = wxString_in_helper(obj3);
39920 if (arg4 == NULL) SWIG_fail;
39921 temp4 = true;
39922 }
39923 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39924 if (!SWIG_IsOK(res5)) {
39925 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39926 }
39927 arg5 = reinterpret_cast< wxMenu * >(argp5);
39928 if (obj5) {
39929 {
39930 arg6 = wxString_in_helper(obj5);
39931 if (arg6 == NULL) SWIG_fail;
39932 temp6 = true;
39933 }
39934 }
39935 {
39936 PyThreadState* __tstate = wxPyBeginAllowThreads();
39937 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39938 wxPyEndAllowThreads(__tstate);
39939 if (PyErr_Occurred()) SWIG_fail;
39940 }
39941 {
39942 resultobj = wxPyMake_wxObject(result, (bool)0);
39943 }
39944 {
39945 if (temp4)
39946 delete arg4;
39947 }
39948 {
39949 if (temp6)
39950 delete arg6;
39951 }
39952 return resultobj;
39953 fail:
39954 {
39955 if (temp4)
39956 delete arg4;
39957 }
39958 {
39959 if (temp6)
39960 delete arg6;
39961 }
39962 return NULL;
39963 }
39964
39965
39966 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39967 PyObject *resultobj = 0;
39968 wxMenu *arg1 = (wxMenu *) 0 ;
39969 int arg2 ;
39970 wxString const &arg3_defvalue = wxPyEmptyString ;
39971 wxString *arg3 = (wxString *) &arg3_defvalue ;
39972 wxString const &arg4_defvalue = wxPyEmptyString ;
39973 wxString *arg4 = (wxString *) &arg4_defvalue ;
39974 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39975 wxMenuItem *result = 0 ;
39976 void *argp1 = 0 ;
39977 int res1 = 0 ;
39978 int val2 ;
39979 int ecode2 = 0 ;
39980 bool temp3 = false ;
39981 bool temp4 = false ;
39982 int val5 ;
39983 int ecode5 = 0 ;
39984 PyObject * obj0 = 0 ;
39985 PyObject * obj1 = 0 ;
39986 PyObject * obj2 = 0 ;
39987 PyObject * obj3 = 0 ;
39988 PyObject * obj4 = 0 ;
39989 char * kwnames[] = {
39990 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39991 };
39992
39993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39995 if (!SWIG_IsOK(res1)) {
39996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39997 }
39998 arg1 = reinterpret_cast< wxMenu * >(argp1);
39999 ecode2 = SWIG_AsVal_int(obj1, &val2);
40000 if (!SWIG_IsOK(ecode2)) {
40001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40002 }
40003 arg2 = static_cast< int >(val2);
40004 if (obj2) {
40005 {
40006 arg3 = wxString_in_helper(obj2);
40007 if (arg3 == NULL) SWIG_fail;
40008 temp3 = true;
40009 }
40010 }
40011 if (obj3) {
40012 {
40013 arg4 = wxString_in_helper(obj3);
40014 if (arg4 == NULL) SWIG_fail;
40015 temp4 = true;
40016 }
40017 }
40018 if (obj4) {
40019 ecode5 = SWIG_AsVal_int(obj4, &val5);
40020 if (!SWIG_IsOK(ecode5)) {
40021 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40022 }
40023 arg5 = static_cast< wxItemKind >(val5);
40024 }
40025 {
40026 PyThreadState* __tstate = wxPyBeginAllowThreads();
40027 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40028 wxPyEndAllowThreads(__tstate);
40029 if (PyErr_Occurred()) SWIG_fail;
40030 }
40031 {
40032 resultobj = wxPyMake_wxObject(result, (bool)0);
40033 }
40034 {
40035 if (temp3)
40036 delete arg3;
40037 }
40038 {
40039 if (temp4)
40040 delete arg4;
40041 }
40042 return resultobj;
40043 fail:
40044 {
40045 if (temp3)
40046 delete arg3;
40047 }
40048 {
40049 if (temp4)
40050 delete arg4;
40051 }
40052 return NULL;
40053 }
40054
40055
40056 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40057 PyObject *resultobj = 0;
40058 wxMenu *arg1 = (wxMenu *) 0 ;
40059 wxMenuItem *result = 0 ;
40060 void *argp1 = 0 ;
40061 int res1 = 0 ;
40062 PyObject *swig_obj[1] ;
40063
40064 if (!args) SWIG_fail;
40065 swig_obj[0] = args;
40066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40067 if (!SWIG_IsOK(res1)) {
40068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40069 }
40070 arg1 = reinterpret_cast< wxMenu * >(argp1);
40071 {
40072 PyThreadState* __tstate = wxPyBeginAllowThreads();
40073 result = (wxMenuItem *)(arg1)->PrependSeparator();
40074 wxPyEndAllowThreads(__tstate);
40075 if (PyErr_Occurred()) SWIG_fail;
40076 }
40077 {
40078 resultobj = wxPyMake_wxObject(result, (bool)0);
40079 }
40080 return resultobj;
40081 fail:
40082 return NULL;
40083 }
40084
40085
40086 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40087 PyObject *resultobj = 0;
40088 wxMenu *arg1 = (wxMenu *) 0 ;
40089 int arg2 ;
40090 wxString *arg3 = 0 ;
40091 wxString const &arg4_defvalue = wxPyEmptyString ;
40092 wxString *arg4 = (wxString *) &arg4_defvalue ;
40093 wxMenuItem *result = 0 ;
40094 void *argp1 = 0 ;
40095 int res1 = 0 ;
40096 int val2 ;
40097 int ecode2 = 0 ;
40098 bool temp3 = false ;
40099 bool temp4 = false ;
40100 PyObject * obj0 = 0 ;
40101 PyObject * obj1 = 0 ;
40102 PyObject * obj2 = 0 ;
40103 PyObject * obj3 = 0 ;
40104 char * kwnames[] = {
40105 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40106 };
40107
40108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40110 if (!SWIG_IsOK(res1)) {
40111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40112 }
40113 arg1 = reinterpret_cast< wxMenu * >(argp1);
40114 ecode2 = SWIG_AsVal_int(obj1, &val2);
40115 if (!SWIG_IsOK(ecode2)) {
40116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40117 }
40118 arg2 = static_cast< int >(val2);
40119 {
40120 arg3 = wxString_in_helper(obj2);
40121 if (arg3 == NULL) SWIG_fail;
40122 temp3 = true;
40123 }
40124 if (obj3) {
40125 {
40126 arg4 = wxString_in_helper(obj3);
40127 if (arg4 == NULL) SWIG_fail;
40128 temp4 = true;
40129 }
40130 }
40131 {
40132 PyThreadState* __tstate = wxPyBeginAllowThreads();
40133 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40134 wxPyEndAllowThreads(__tstate);
40135 if (PyErr_Occurred()) SWIG_fail;
40136 }
40137 {
40138 resultobj = wxPyMake_wxObject(result, (bool)0);
40139 }
40140 {
40141 if (temp3)
40142 delete arg3;
40143 }
40144 {
40145 if (temp4)
40146 delete arg4;
40147 }
40148 return resultobj;
40149 fail:
40150 {
40151 if (temp3)
40152 delete arg3;
40153 }
40154 {
40155 if (temp4)
40156 delete arg4;
40157 }
40158 return NULL;
40159 }
40160
40161
40162 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40163 PyObject *resultobj = 0;
40164 wxMenu *arg1 = (wxMenu *) 0 ;
40165 int arg2 ;
40166 wxString *arg3 = 0 ;
40167 wxString const &arg4_defvalue = wxPyEmptyString ;
40168 wxString *arg4 = (wxString *) &arg4_defvalue ;
40169 wxMenuItem *result = 0 ;
40170 void *argp1 = 0 ;
40171 int res1 = 0 ;
40172 int val2 ;
40173 int ecode2 = 0 ;
40174 bool temp3 = false ;
40175 bool temp4 = false ;
40176 PyObject * obj0 = 0 ;
40177 PyObject * obj1 = 0 ;
40178 PyObject * obj2 = 0 ;
40179 PyObject * obj3 = 0 ;
40180 char * kwnames[] = {
40181 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40182 };
40183
40184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40186 if (!SWIG_IsOK(res1)) {
40187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40188 }
40189 arg1 = reinterpret_cast< wxMenu * >(argp1);
40190 ecode2 = SWIG_AsVal_int(obj1, &val2);
40191 if (!SWIG_IsOK(ecode2)) {
40192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40193 }
40194 arg2 = static_cast< int >(val2);
40195 {
40196 arg3 = wxString_in_helper(obj2);
40197 if (arg3 == NULL) SWIG_fail;
40198 temp3 = true;
40199 }
40200 if (obj3) {
40201 {
40202 arg4 = wxString_in_helper(obj3);
40203 if (arg4 == NULL) SWIG_fail;
40204 temp4 = true;
40205 }
40206 }
40207 {
40208 PyThreadState* __tstate = wxPyBeginAllowThreads();
40209 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40210 wxPyEndAllowThreads(__tstate);
40211 if (PyErr_Occurred()) SWIG_fail;
40212 }
40213 {
40214 resultobj = wxPyMake_wxObject(result, (bool)0);
40215 }
40216 {
40217 if (temp3)
40218 delete arg3;
40219 }
40220 {
40221 if (temp4)
40222 delete arg4;
40223 }
40224 return resultobj;
40225 fail:
40226 {
40227 if (temp3)
40228 delete arg3;
40229 }
40230 {
40231 if (temp4)
40232 delete arg4;
40233 }
40234 return NULL;
40235 }
40236
40237
40238 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40239 PyObject *resultobj = 0;
40240 wxMenu *arg1 = (wxMenu *) 0 ;
40241 int arg2 ;
40242 wxString *arg3 = 0 ;
40243 wxMenu *arg4 = (wxMenu *) 0 ;
40244 wxString const &arg5_defvalue = wxPyEmptyString ;
40245 wxString *arg5 = (wxString *) &arg5_defvalue ;
40246 wxMenuItem *result = 0 ;
40247 void *argp1 = 0 ;
40248 int res1 = 0 ;
40249 int val2 ;
40250 int ecode2 = 0 ;
40251 bool temp3 = false ;
40252 void *argp4 = 0 ;
40253 int res4 = 0 ;
40254 bool temp5 = false ;
40255 PyObject * obj0 = 0 ;
40256 PyObject * obj1 = 0 ;
40257 PyObject * obj2 = 0 ;
40258 PyObject * obj3 = 0 ;
40259 PyObject * obj4 = 0 ;
40260 char * kwnames[] = {
40261 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40262 };
40263
40264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40266 if (!SWIG_IsOK(res1)) {
40267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40268 }
40269 arg1 = reinterpret_cast< wxMenu * >(argp1);
40270 ecode2 = SWIG_AsVal_int(obj1, &val2);
40271 if (!SWIG_IsOK(ecode2)) {
40272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40273 }
40274 arg2 = static_cast< int >(val2);
40275 {
40276 arg3 = wxString_in_helper(obj2);
40277 if (arg3 == NULL) SWIG_fail;
40278 temp3 = true;
40279 }
40280 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40281 if (!SWIG_IsOK(res4)) {
40282 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40283 }
40284 arg4 = reinterpret_cast< wxMenu * >(argp4);
40285 if (obj4) {
40286 {
40287 arg5 = wxString_in_helper(obj4);
40288 if (arg5 == NULL) SWIG_fail;
40289 temp5 = true;
40290 }
40291 }
40292 {
40293 PyThreadState* __tstate = wxPyBeginAllowThreads();
40294 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40295 wxPyEndAllowThreads(__tstate);
40296 if (PyErr_Occurred()) SWIG_fail;
40297 }
40298 {
40299 resultobj = wxPyMake_wxObject(result, (bool)0);
40300 }
40301 {
40302 if (temp3)
40303 delete arg3;
40304 }
40305 {
40306 if (temp5)
40307 delete arg5;
40308 }
40309 return resultobj;
40310 fail:
40311 {
40312 if (temp3)
40313 delete arg3;
40314 }
40315 {
40316 if (temp5)
40317 delete arg5;
40318 }
40319 return NULL;
40320 }
40321
40322
40323 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40324 PyObject *resultobj = 0;
40325 wxMenu *arg1 = (wxMenu *) 0 ;
40326 int arg2 ;
40327 wxMenuItem *result = 0 ;
40328 void *argp1 = 0 ;
40329 int res1 = 0 ;
40330 int val2 ;
40331 int ecode2 = 0 ;
40332 PyObject * obj0 = 0 ;
40333 PyObject * obj1 = 0 ;
40334 char * kwnames[] = {
40335 (char *) "self",(char *) "id", NULL
40336 };
40337
40338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40340 if (!SWIG_IsOK(res1)) {
40341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40342 }
40343 arg1 = reinterpret_cast< wxMenu * >(argp1);
40344 ecode2 = SWIG_AsVal_int(obj1, &val2);
40345 if (!SWIG_IsOK(ecode2)) {
40346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40347 }
40348 arg2 = static_cast< int >(val2);
40349 {
40350 PyThreadState* __tstate = wxPyBeginAllowThreads();
40351 result = (wxMenuItem *)(arg1)->Remove(arg2);
40352 wxPyEndAllowThreads(__tstate);
40353 if (PyErr_Occurred()) SWIG_fail;
40354 }
40355 {
40356 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40357 }
40358 return resultobj;
40359 fail:
40360 return NULL;
40361 }
40362
40363
40364 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40365 PyObject *resultobj = 0;
40366 wxMenu *arg1 = (wxMenu *) 0 ;
40367 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40368 wxMenuItem *result = 0 ;
40369 void *argp1 = 0 ;
40370 int res1 = 0 ;
40371 void *argp2 = 0 ;
40372 int res2 = 0 ;
40373 PyObject * obj0 = 0 ;
40374 PyObject * obj1 = 0 ;
40375 char * kwnames[] = {
40376 (char *) "self",(char *) "item", NULL
40377 };
40378
40379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40381 if (!SWIG_IsOK(res1)) {
40382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40383 }
40384 arg1 = reinterpret_cast< wxMenu * >(argp1);
40385 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40386 if (!SWIG_IsOK(res2)) {
40387 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40388 }
40389 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40390 {
40391 PyThreadState* __tstate = wxPyBeginAllowThreads();
40392 result = (wxMenuItem *)(arg1)->Remove(arg2);
40393 wxPyEndAllowThreads(__tstate);
40394 if (PyErr_Occurred()) SWIG_fail;
40395 }
40396 {
40397 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40398 }
40399 return resultobj;
40400 fail:
40401 return NULL;
40402 }
40403
40404
40405 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40406 PyObject *resultobj = 0;
40407 wxMenu *arg1 = (wxMenu *) 0 ;
40408 int arg2 ;
40409 bool result;
40410 void *argp1 = 0 ;
40411 int res1 = 0 ;
40412 int val2 ;
40413 int ecode2 = 0 ;
40414 PyObject * obj0 = 0 ;
40415 PyObject * obj1 = 0 ;
40416 char * kwnames[] = {
40417 (char *) "self",(char *) "id", NULL
40418 };
40419
40420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40422 if (!SWIG_IsOK(res1)) {
40423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40424 }
40425 arg1 = reinterpret_cast< wxMenu * >(argp1);
40426 ecode2 = SWIG_AsVal_int(obj1, &val2);
40427 if (!SWIG_IsOK(ecode2)) {
40428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40429 }
40430 arg2 = static_cast< int >(val2);
40431 {
40432 PyThreadState* __tstate = wxPyBeginAllowThreads();
40433 result = (bool)(arg1)->Delete(arg2);
40434 wxPyEndAllowThreads(__tstate);
40435 if (PyErr_Occurred()) SWIG_fail;
40436 }
40437 {
40438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40439 }
40440 return resultobj;
40441 fail:
40442 return NULL;
40443 }
40444
40445
40446 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40447 PyObject *resultobj = 0;
40448 wxMenu *arg1 = (wxMenu *) 0 ;
40449 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40450 bool result;
40451 void *argp1 = 0 ;
40452 int res1 = 0 ;
40453 void *argp2 = 0 ;
40454 int res2 = 0 ;
40455 PyObject * obj0 = 0 ;
40456 PyObject * obj1 = 0 ;
40457 char * kwnames[] = {
40458 (char *) "self",(char *) "item", NULL
40459 };
40460
40461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40463 if (!SWIG_IsOK(res1)) {
40464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40465 }
40466 arg1 = reinterpret_cast< wxMenu * >(argp1);
40467 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40468 if (!SWIG_IsOK(res2)) {
40469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40470 }
40471 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40472 {
40473 PyThreadState* __tstate = wxPyBeginAllowThreads();
40474 result = (bool)(arg1)->Delete(arg2);
40475 wxPyEndAllowThreads(__tstate);
40476 if (PyErr_Occurred()) SWIG_fail;
40477 }
40478 {
40479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40480 }
40481 return resultobj;
40482 fail:
40483 return NULL;
40484 }
40485
40486
40487 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40488 PyObject *resultobj = 0;
40489 wxMenu *arg1 = (wxMenu *) 0 ;
40490 void *argp1 = 0 ;
40491 int res1 = 0 ;
40492 PyObject *swig_obj[1] ;
40493
40494 if (!args) SWIG_fail;
40495 swig_obj[0] = args;
40496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40497 if (!SWIG_IsOK(res1)) {
40498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40499 }
40500 arg1 = reinterpret_cast< wxMenu * >(argp1);
40501 {
40502 PyThreadState* __tstate = wxPyBeginAllowThreads();
40503 wxMenu_Destroy(arg1);
40504 wxPyEndAllowThreads(__tstate);
40505 if (PyErr_Occurred()) SWIG_fail;
40506 }
40507 resultobj = SWIG_Py_Void();
40508 return resultobj;
40509 fail:
40510 return NULL;
40511 }
40512
40513
40514 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40515 PyObject *resultobj = 0;
40516 wxMenu *arg1 = (wxMenu *) 0 ;
40517 int arg2 ;
40518 bool result;
40519 void *argp1 = 0 ;
40520 int res1 = 0 ;
40521 int val2 ;
40522 int ecode2 = 0 ;
40523 PyObject * obj0 = 0 ;
40524 PyObject * obj1 = 0 ;
40525 char * kwnames[] = {
40526 (char *) "self",(char *) "id", NULL
40527 };
40528
40529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40531 if (!SWIG_IsOK(res1)) {
40532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40533 }
40534 arg1 = reinterpret_cast< wxMenu * >(argp1);
40535 ecode2 = SWIG_AsVal_int(obj1, &val2);
40536 if (!SWIG_IsOK(ecode2)) {
40537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40538 }
40539 arg2 = static_cast< int >(val2);
40540 {
40541 PyThreadState* __tstate = wxPyBeginAllowThreads();
40542 result = (bool)(arg1)->Destroy(arg2);
40543 wxPyEndAllowThreads(__tstate);
40544 if (PyErr_Occurred()) SWIG_fail;
40545 }
40546 {
40547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40548 }
40549 return resultobj;
40550 fail:
40551 return NULL;
40552 }
40553
40554
40555 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40556 PyObject *resultobj = 0;
40557 wxMenu *arg1 = (wxMenu *) 0 ;
40558 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40559 bool result;
40560 void *argp1 = 0 ;
40561 int res1 = 0 ;
40562 void *argp2 = 0 ;
40563 int res2 = 0 ;
40564 PyObject * obj0 = 0 ;
40565 PyObject * obj1 = 0 ;
40566 char * kwnames[] = {
40567 (char *) "self",(char *) "item", NULL
40568 };
40569
40570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40572 if (!SWIG_IsOK(res1)) {
40573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40574 }
40575 arg1 = reinterpret_cast< wxMenu * >(argp1);
40576 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40577 if (!SWIG_IsOK(res2)) {
40578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40579 }
40580 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40581 {
40582 PyThreadState* __tstate = wxPyBeginAllowThreads();
40583 result = (bool)(arg1)->Destroy(arg2);
40584 wxPyEndAllowThreads(__tstate);
40585 if (PyErr_Occurred()) SWIG_fail;
40586 }
40587 {
40588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40589 }
40590 return resultobj;
40591 fail:
40592 return NULL;
40593 }
40594
40595
40596 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40597 PyObject *resultobj = 0;
40598 wxMenu *arg1 = (wxMenu *) 0 ;
40599 size_t result;
40600 void *argp1 = 0 ;
40601 int res1 = 0 ;
40602 PyObject *swig_obj[1] ;
40603
40604 if (!args) SWIG_fail;
40605 swig_obj[0] = args;
40606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40607 if (!SWIG_IsOK(res1)) {
40608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40609 }
40610 arg1 = reinterpret_cast< wxMenu * >(argp1);
40611 {
40612 PyThreadState* __tstate = wxPyBeginAllowThreads();
40613 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40614 wxPyEndAllowThreads(__tstate);
40615 if (PyErr_Occurred()) SWIG_fail;
40616 }
40617 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40618 return resultobj;
40619 fail:
40620 return NULL;
40621 }
40622
40623
40624 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40625 PyObject *resultobj = 0;
40626 wxMenu *arg1 = (wxMenu *) 0 ;
40627 PyObject *result = 0 ;
40628 void *argp1 = 0 ;
40629 int res1 = 0 ;
40630 PyObject *swig_obj[1] ;
40631
40632 if (!args) SWIG_fail;
40633 swig_obj[0] = args;
40634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40635 if (!SWIG_IsOK(res1)) {
40636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40637 }
40638 arg1 = reinterpret_cast< wxMenu * >(argp1);
40639 {
40640 PyThreadState* __tstate = wxPyBeginAllowThreads();
40641 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40642 wxPyEndAllowThreads(__tstate);
40643 if (PyErr_Occurred()) SWIG_fail;
40644 }
40645 resultobj = result;
40646 return resultobj;
40647 fail:
40648 return NULL;
40649 }
40650
40651
40652 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40653 PyObject *resultobj = 0;
40654 wxMenu *arg1 = (wxMenu *) 0 ;
40655 wxString *arg2 = 0 ;
40656 int result;
40657 void *argp1 = 0 ;
40658 int res1 = 0 ;
40659 bool temp2 = false ;
40660 PyObject * obj0 = 0 ;
40661 PyObject * obj1 = 0 ;
40662 char * kwnames[] = {
40663 (char *) "self",(char *) "item", NULL
40664 };
40665
40666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40668 if (!SWIG_IsOK(res1)) {
40669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40670 }
40671 arg1 = reinterpret_cast< wxMenu * >(argp1);
40672 {
40673 arg2 = wxString_in_helper(obj1);
40674 if (arg2 == NULL) SWIG_fail;
40675 temp2 = true;
40676 }
40677 {
40678 PyThreadState* __tstate = wxPyBeginAllowThreads();
40679 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40680 wxPyEndAllowThreads(__tstate);
40681 if (PyErr_Occurred()) SWIG_fail;
40682 }
40683 resultobj = SWIG_From_int(static_cast< int >(result));
40684 {
40685 if (temp2)
40686 delete arg2;
40687 }
40688 return resultobj;
40689 fail:
40690 {
40691 if (temp2)
40692 delete arg2;
40693 }
40694 return NULL;
40695 }
40696
40697
40698 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40699 PyObject *resultobj = 0;
40700 wxMenu *arg1 = (wxMenu *) 0 ;
40701 int arg2 ;
40702 wxMenuItem *result = 0 ;
40703 void *argp1 = 0 ;
40704 int res1 = 0 ;
40705 int val2 ;
40706 int ecode2 = 0 ;
40707 PyObject * obj0 = 0 ;
40708 PyObject * obj1 = 0 ;
40709 char * kwnames[] = {
40710 (char *) "self",(char *) "id", NULL
40711 };
40712
40713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40715 if (!SWIG_IsOK(res1)) {
40716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40717 }
40718 arg1 = reinterpret_cast< wxMenu * >(argp1);
40719 ecode2 = SWIG_AsVal_int(obj1, &val2);
40720 if (!SWIG_IsOK(ecode2)) {
40721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40722 }
40723 arg2 = static_cast< int >(val2);
40724 {
40725 PyThreadState* __tstate = wxPyBeginAllowThreads();
40726 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40727 wxPyEndAllowThreads(__tstate);
40728 if (PyErr_Occurred()) SWIG_fail;
40729 }
40730 {
40731 resultobj = wxPyMake_wxObject(result, (bool)0);
40732 }
40733 return resultobj;
40734 fail:
40735 return NULL;
40736 }
40737
40738
40739 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40740 PyObject *resultobj = 0;
40741 wxMenu *arg1 = (wxMenu *) 0 ;
40742 size_t arg2 ;
40743 wxMenuItem *result = 0 ;
40744 void *argp1 = 0 ;
40745 int res1 = 0 ;
40746 size_t val2 ;
40747 int ecode2 = 0 ;
40748 PyObject * obj0 = 0 ;
40749 PyObject * obj1 = 0 ;
40750 char * kwnames[] = {
40751 (char *) "self",(char *) "position", NULL
40752 };
40753
40754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40756 if (!SWIG_IsOK(res1)) {
40757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40758 }
40759 arg1 = reinterpret_cast< wxMenu * >(argp1);
40760 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40761 if (!SWIG_IsOK(ecode2)) {
40762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40763 }
40764 arg2 = static_cast< size_t >(val2);
40765 {
40766 PyThreadState* __tstate = wxPyBeginAllowThreads();
40767 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40768 wxPyEndAllowThreads(__tstate);
40769 if (PyErr_Occurred()) SWIG_fail;
40770 }
40771 {
40772 resultobj = wxPyMake_wxObject(result, (bool)0);
40773 }
40774 return resultobj;
40775 fail:
40776 return NULL;
40777 }
40778
40779
40780 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40781 PyObject *resultobj = 0;
40782 wxMenu *arg1 = (wxMenu *) 0 ;
40783 int arg2 ;
40784 bool arg3 ;
40785 void *argp1 = 0 ;
40786 int res1 = 0 ;
40787 int val2 ;
40788 int ecode2 = 0 ;
40789 bool val3 ;
40790 int ecode3 = 0 ;
40791 PyObject * obj0 = 0 ;
40792 PyObject * obj1 = 0 ;
40793 PyObject * obj2 = 0 ;
40794 char * kwnames[] = {
40795 (char *) "self",(char *) "id",(char *) "enable", NULL
40796 };
40797
40798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40800 if (!SWIG_IsOK(res1)) {
40801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40802 }
40803 arg1 = reinterpret_cast< wxMenu * >(argp1);
40804 ecode2 = SWIG_AsVal_int(obj1, &val2);
40805 if (!SWIG_IsOK(ecode2)) {
40806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40807 }
40808 arg2 = static_cast< int >(val2);
40809 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40810 if (!SWIG_IsOK(ecode3)) {
40811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40812 }
40813 arg3 = static_cast< bool >(val3);
40814 {
40815 PyThreadState* __tstate = wxPyBeginAllowThreads();
40816 (arg1)->Enable(arg2,arg3);
40817 wxPyEndAllowThreads(__tstate);
40818 if (PyErr_Occurred()) SWIG_fail;
40819 }
40820 resultobj = SWIG_Py_Void();
40821 return resultobj;
40822 fail:
40823 return NULL;
40824 }
40825
40826
40827 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40828 PyObject *resultobj = 0;
40829 wxMenu *arg1 = (wxMenu *) 0 ;
40830 int arg2 ;
40831 bool result;
40832 void *argp1 = 0 ;
40833 int res1 = 0 ;
40834 int val2 ;
40835 int ecode2 = 0 ;
40836 PyObject * obj0 = 0 ;
40837 PyObject * obj1 = 0 ;
40838 char * kwnames[] = {
40839 (char *) "self",(char *) "id", NULL
40840 };
40841
40842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40844 if (!SWIG_IsOK(res1)) {
40845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40846 }
40847 arg1 = reinterpret_cast< wxMenu * >(argp1);
40848 ecode2 = SWIG_AsVal_int(obj1, &val2);
40849 if (!SWIG_IsOK(ecode2)) {
40850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40851 }
40852 arg2 = static_cast< int >(val2);
40853 {
40854 PyThreadState* __tstate = wxPyBeginAllowThreads();
40855 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40856 wxPyEndAllowThreads(__tstate);
40857 if (PyErr_Occurred()) SWIG_fail;
40858 }
40859 {
40860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40861 }
40862 return resultobj;
40863 fail:
40864 return NULL;
40865 }
40866
40867
40868 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40869 PyObject *resultobj = 0;
40870 wxMenu *arg1 = (wxMenu *) 0 ;
40871 int arg2 ;
40872 bool arg3 ;
40873 void *argp1 = 0 ;
40874 int res1 = 0 ;
40875 int val2 ;
40876 int ecode2 = 0 ;
40877 bool val3 ;
40878 int ecode3 = 0 ;
40879 PyObject * obj0 = 0 ;
40880 PyObject * obj1 = 0 ;
40881 PyObject * obj2 = 0 ;
40882 char * kwnames[] = {
40883 (char *) "self",(char *) "id",(char *) "check", NULL
40884 };
40885
40886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40888 if (!SWIG_IsOK(res1)) {
40889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40890 }
40891 arg1 = reinterpret_cast< wxMenu * >(argp1);
40892 ecode2 = SWIG_AsVal_int(obj1, &val2);
40893 if (!SWIG_IsOK(ecode2)) {
40894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40895 }
40896 arg2 = static_cast< int >(val2);
40897 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40898 if (!SWIG_IsOK(ecode3)) {
40899 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40900 }
40901 arg3 = static_cast< bool >(val3);
40902 {
40903 PyThreadState* __tstate = wxPyBeginAllowThreads();
40904 (arg1)->Check(arg2,arg3);
40905 wxPyEndAllowThreads(__tstate);
40906 if (PyErr_Occurred()) SWIG_fail;
40907 }
40908 resultobj = SWIG_Py_Void();
40909 return resultobj;
40910 fail:
40911 return NULL;
40912 }
40913
40914
40915 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40916 PyObject *resultobj = 0;
40917 wxMenu *arg1 = (wxMenu *) 0 ;
40918 int arg2 ;
40919 bool result;
40920 void *argp1 = 0 ;
40921 int res1 = 0 ;
40922 int val2 ;
40923 int ecode2 = 0 ;
40924 PyObject * obj0 = 0 ;
40925 PyObject * obj1 = 0 ;
40926 char * kwnames[] = {
40927 (char *) "self",(char *) "id", NULL
40928 };
40929
40930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40932 if (!SWIG_IsOK(res1)) {
40933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40934 }
40935 arg1 = reinterpret_cast< wxMenu * >(argp1);
40936 ecode2 = SWIG_AsVal_int(obj1, &val2);
40937 if (!SWIG_IsOK(ecode2)) {
40938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40939 }
40940 arg2 = static_cast< int >(val2);
40941 {
40942 PyThreadState* __tstate = wxPyBeginAllowThreads();
40943 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40944 wxPyEndAllowThreads(__tstate);
40945 if (PyErr_Occurred()) SWIG_fail;
40946 }
40947 {
40948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40949 }
40950 return resultobj;
40951 fail:
40952 return NULL;
40953 }
40954
40955
40956 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40957 PyObject *resultobj = 0;
40958 wxMenu *arg1 = (wxMenu *) 0 ;
40959 int arg2 ;
40960 wxString *arg3 = 0 ;
40961 void *argp1 = 0 ;
40962 int res1 = 0 ;
40963 int val2 ;
40964 int ecode2 = 0 ;
40965 bool temp3 = false ;
40966 PyObject * obj0 = 0 ;
40967 PyObject * obj1 = 0 ;
40968 PyObject * obj2 = 0 ;
40969 char * kwnames[] = {
40970 (char *) "self",(char *) "id",(char *) "label", NULL
40971 };
40972
40973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40975 if (!SWIG_IsOK(res1)) {
40976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40977 }
40978 arg1 = reinterpret_cast< wxMenu * >(argp1);
40979 ecode2 = SWIG_AsVal_int(obj1, &val2);
40980 if (!SWIG_IsOK(ecode2)) {
40981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40982 }
40983 arg2 = static_cast< int >(val2);
40984 {
40985 arg3 = wxString_in_helper(obj2);
40986 if (arg3 == NULL) SWIG_fail;
40987 temp3 = true;
40988 }
40989 {
40990 PyThreadState* __tstate = wxPyBeginAllowThreads();
40991 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40992 wxPyEndAllowThreads(__tstate);
40993 if (PyErr_Occurred()) SWIG_fail;
40994 }
40995 resultobj = SWIG_Py_Void();
40996 {
40997 if (temp3)
40998 delete arg3;
40999 }
41000 return resultobj;
41001 fail:
41002 {
41003 if (temp3)
41004 delete arg3;
41005 }
41006 return NULL;
41007 }
41008
41009
41010 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41011 PyObject *resultobj = 0;
41012 wxMenu *arg1 = (wxMenu *) 0 ;
41013 int arg2 ;
41014 wxString result;
41015 void *argp1 = 0 ;
41016 int res1 = 0 ;
41017 int val2 ;
41018 int ecode2 = 0 ;
41019 PyObject * obj0 = 0 ;
41020 PyObject * obj1 = 0 ;
41021 char * kwnames[] = {
41022 (char *) "self",(char *) "id", NULL
41023 };
41024
41025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41027 if (!SWIG_IsOK(res1)) {
41028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41029 }
41030 arg1 = reinterpret_cast< wxMenu * >(argp1);
41031 ecode2 = SWIG_AsVal_int(obj1, &val2);
41032 if (!SWIG_IsOK(ecode2)) {
41033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41034 }
41035 arg2 = static_cast< int >(val2);
41036 {
41037 PyThreadState* __tstate = wxPyBeginAllowThreads();
41038 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41039 wxPyEndAllowThreads(__tstate);
41040 if (PyErr_Occurred()) SWIG_fail;
41041 }
41042 {
41043 #if wxUSE_UNICODE
41044 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41045 #else
41046 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41047 #endif
41048 }
41049 return resultobj;
41050 fail:
41051 return NULL;
41052 }
41053
41054
41055 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41056 PyObject *resultobj = 0;
41057 wxMenu *arg1 = (wxMenu *) 0 ;
41058 int arg2 ;
41059 wxString *arg3 = 0 ;
41060 void *argp1 = 0 ;
41061 int res1 = 0 ;
41062 int val2 ;
41063 int ecode2 = 0 ;
41064 bool temp3 = false ;
41065 PyObject * obj0 = 0 ;
41066 PyObject * obj1 = 0 ;
41067 PyObject * obj2 = 0 ;
41068 char * kwnames[] = {
41069 (char *) "self",(char *) "id",(char *) "helpString", NULL
41070 };
41071
41072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41074 if (!SWIG_IsOK(res1)) {
41075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41076 }
41077 arg1 = reinterpret_cast< wxMenu * >(argp1);
41078 ecode2 = SWIG_AsVal_int(obj1, &val2);
41079 if (!SWIG_IsOK(ecode2)) {
41080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41081 }
41082 arg2 = static_cast< int >(val2);
41083 {
41084 arg3 = wxString_in_helper(obj2);
41085 if (arg3 == NULL) SWIG_fail;
41086 temp3 = true;
41087 }
41088 {
41089 PyThreadState* __tstate = wxPyBeginAllowThreads();
41090 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41091 wxPyEndAllowThreads(__tstate);
41092 if (PyErr_Occurred()) SWIG_fail;
41093 }
41094 resultobj = SWIG_Py_Void();
41095 {
41096 if (temp3)
41097 delete arg3;
41098 }
41099 return resultobj;
41100 fail:
41101 {
41102 if (temp3)
41103 delete arg3;
41104 }
41105 return NULL;
41106 }
41107
41108
41109 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41110 PyObject *resultobj = 0;
41111 wxMenu *arg1 = (wxMenu *) 0 ;
41112 int arg2 ;
41113 wxString result;
41114 void *argp1 = 0 ;
41115 int res1 = 0 ;
41116 int val2 ;
41117 int ecode2 = 0 ;
41118 PyObject * obj0 = 0 ;
41119 PyObject * obj1 = 0 ;
41120 char * kwnames[] = {
41121 (char *) "self",(char *) "id", NULL
41122 };
41123
41124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41126 if (!SWIG_IsOK(res1)) {
41127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41128 }
41129 arg1 = reinterpret_cast< wxMenu * >(argp1);
41130 ecode2 = SWIG_AsVal_int(obj1, &val2);
41131 if (!SWIG_IsOK(ecode2)) {
41132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41133 }
41134 arg2 = static_cast< int >(val2);
41135 {
41136 PyThreadState* __tstate = wxPyBeginAllowThreads();
41137 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41138 wxPyEndAllowThreads(__tstate);
41139 if (PyErr_Occurred()) SWIG_fail;
41140 }
41141 {
41142 #if wxUSE_UNICODE
41143 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41144 #else
41145 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41146 #endif
41147 }
41148 return resultobj;
41149 fail:
41150 return NULL;
41151 }
41152
41153
41154 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41155 PyObject *resultobj = 0;
41156 wxMenu *arg1 = (wxMenu *) 0 ;
41157 wxString *arg2 = 0 ;
41158 void *argp1 = 0 ;
41159 int res1 = 0 ;
41160 bool temp2 = false ;
41161 PyObject * obj0 = 0 ;
41162 PyObject * obj1 = 0 ;
41163 char * kwnames[] = {
41164 (char *) "self",(char *) "title", NULL
41165 };
41166
41167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41169 if (!SWIG_IsOK(res1)) {
41170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41171 }
41172 arg1 = reinterpret_cast< wxMenu * >(argp1);
41173 {
41174 arg2 = wxString_in_helper(obj1);
41175 if (arg2 == NULL) SWIG_fail;
41176 temp2 = true;
41177 }
41178 {
41179 PyThreadState* __tstate = wxPyBeginAllowThreads();
41180 (arg1)->SetTitle((wxString const &)*arg2);
41181 wxPyEndAllowThreads(__tstate);
41182 if (PyErr_Occurred()) SWIG_fail;
41183 }
41184 resultobj = SWIG_Py_Void();
41185 {
41186 if (temp2)
41187 delete arg2;
41188 }
41189 return resultobj;
41190 fail:
41191 {
41192 if (temp2)
41193 delete arg2;
41194 }
41195 return NULL;
41196 }
41197
41198
41199 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41200 PyObject *resultobj = 0;
41201 wxMenu *arg1 = (wxMenu *) 0 ;
41202 wxString result;
41203 void *argp1 = 0 ;
41204 int res1 = 0 ;
41205 PyObject *swig_obj[1] ;
41206
41207 if (!args) SWIG_fail;
41208 swig_obj[0] = args;
41209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41210 if (!SWIG_IsOK(res1)) {
41211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41212 }
41213 arg1 = reinterpret_cast< wxMenu * >(argp1);
41214 {
41215 PyThreadState* __tstate = wxPyBeginAllowThreads();
41216 result = ((wxMenu const *)arg1)->GetTitle();
41217 wxPyEndAllowThreads(__tstate);
41218 if (PyErr_Occurred()) SWIG_fail;
41219 }
41220 {
41221 #if wxUSE_UNICODE
41222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41223 #else
41224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41225 #endif
41226 }
41227 return resultobj;
41228 fail:
41229 return NULL;
41230 }
41231
41232
41233 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41234 PyObject *resultobj = 0;
41235 wxMenu *arg1 = (wxMenu *) 0 ;
41236 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41237 void *argp1 = 0 ;
41238 int res1 = 0 ;
41239 void *argp2 = 0 ;
41240 int res2 = 0 ;
41241 PyObject * obj0 = 0 ;
41242 PyObject * obj1 = 0 ;
41243 char * kwnames[] = {
41244 (char *) "self",(char *) "handler", NULL
41245 };
41246
41247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41249 if (!SWIG_IsOK(res1)) {
41250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41251 }
41252 arg1 = reinterpret_cast< wxMenu * >(argp1);
41253 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41254 if (!SWIG_IsOK(res2)) {
41255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41256 }
41257 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41258 {
41259 PyThreadState* __tstate = wxPyBeginAllowThreads();
41260 (arg1)->SetEventHandler(arg2);
41261 wxPyEndAllowThreads(__tstate);
41262 if (PyErr_Occurred()) SWIG_fail;
41263 }
41264 resultobj = SWIG_Py_Void();
41265 return resultobj;
41266 fail:
41267 return NULL;
41268 }
41269
41270
41271 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41272 PyObject *resultobj = 0;
41273 wxMenu *arg1 = (wxMenu *) 0 ;
41274 wxEvtHandler *result = 0 ;
41275 void *argp1 = 0 ;
41276 int res1 = 0 ;
41277 PyObject *swig_obj[1] ;
41278
41279 if (!args) SWIG_fail;
41280 swig_obj[0] = args;
41281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41282 if (!SWIG_IsOK(res1)) {
41283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41284 }
41285 arg1 = reinterpret_cast< wxMenu * >(argp1);
41286 {
41287 PyThreadState* __tstate = wxPyBeginAllowThreads();
41288 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41289 wxPyEndAllowThreads(__tstate);
41290 if (PyErr_Occurred()) SWIG_fail;
41291 }
41292 {
41293 resultobj = wxPyMake_wxObject(result, 0);
41294 }
41295 return resultobj;
41296 fail:
41297 return NULL;
41298 }
41299
41300
41301 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41302 PyObject *resultobj = 0;
41303 wxMenu *arg1 = (wxMenu *) 0 ;
41304 wxWindow *arg2 = (wxWindow *) 0 ;
41305 void *argp1 = 0 ;
41306 int res1 = 0 ;
41307 void *argp2 = 0 ;
41308 int res2 = 0 ;
41309 PyObject * obj0 = 0 ;
41310 PyObject * obj1 = 0 ;
41311 char * kwnames[] = {
41312 (char *) "self",(char *) "win", NULL
41313 };
41314
41315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41317 if (!SWIG_IsOK(res1)) {
41318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41319 }
41320 arg1 = reinterpret_cast< wxMenu * >(argp1);
41321 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41322 if (!SWIG_IsOK(res2)) {
41323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41324 }
41325 arg2 = reinterpret_cast< wxWindow * >(argp2);
41326 {
41327 PyThreadState* __tstate = wxPyBeginAllowThreads();
41328 (arg1)->SetInvokingWindow(arg2);
41329 wxPyEndAllowThreads(__tstate);
41330 if (PyErr_Occurred()) SWIG_fail;
41331 }
41332 resultobj = SWIG_Py_Void();
41333 return resultobj;
41334 fail:
41335 return NULL;
41336 }
41337
41338
41339 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41340 PyObject *resultobj = 0;
41341 wxMenu *arg1 = (wxMenu *) 0 ;
41342 wxWindow *result = 0 ;
41343 void *argp1 = 0 ;
41344 int res1 = 0 ;
41345 PyObject *swig_obj[1] ;
41346
41347 if (!args) SWIG_fail;
41348 swig_obj[0] = args;
41349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41350 if (!SWIG_IsOK(res1)) {
41351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41352 }
41353 arg1 = reinterpret_cast< wxMenu * >(argp1);
41354 {
41355 PyThreadState* __tstate = wxPyBeginAllowThreads();
41356 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41357 wxPyEndAllowThreads(__tstate);
41358 if (PyErr_Occurred()) SWIG_fail;
41359 }
41360 {
41361 resultobj = wxPyMake_wxObject(result, 0);
41362 }
41363 return resultobj;
41364 fail:
41365 return NULL;
41366 }
41367
41368
41369 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41370 PyObject *resultobj = 0;
41371 wxMenu *arg1 = (wxMenu *) 0 ;
41372 long result;
41373 void *argp1 = 0 ;
41374 int res1 = 0 ;
41375 PyObject *swig_obj[1] ;
41376
41377 if (!args) SWIG_fail;
41378 swig_obj[0] = args;
41379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41380 if (!SWIG_IsOK(res1)) {
41381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41382 }
41383 arg1 = reinterpret_cast< wxMenu * >(argp1);
41384 {
41385 PyThreadState* __tstate = wxPyBeginAllowThreads();
41386 result = (long)((wxMenu const *)arg1)->GetStyle();
41387 wxPyEndAllowThreads(__tstate);
41388 if (PyErr_Occurred()) SWIG_fail;
41389 }
41390 resultobj = SWIG_From_long(static_cast< long >(result));
41391 return resultobj;
41392 fail:
41393 return NULL;
41394 }
41395
41396
41397 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41398 PyObject *resultobj = 0;
41399 wxMenu *arg1 = (wxMenu *) 0 ;
41400 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
41401 void *argp1 = 0 ;
41402 int res1 = 0 ;
41403 void *argp2 = 0 ;
41404 int res2 = 0 ;
41405 PyObject * obj0 = 0 ;
41406 PyObject * obj1 = 0 ;
41407 char * kwnames[] = {
41408 (char *) "self",(char *) "source", NULL
41409 };
41410
41411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41413 if (!SWIG_IsOK(res1)) {
41414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41415 }
41416 arg1 = reinterpret_cast< wxMenu * >(argp1);
41417 if (obj1) {
41418 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41419 if (!SWIG_IsOK(res2)) {
41420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41421 }
41422 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41423 }
41424 {
41425 PyThreadState* __tstate = wxPyBeginAllowThreads();
41426 (arg1)->UpdateUI(arg2);
41427 wxPyEndAllowThreads(__tstate);
41428 if (PyErr_Occurred()) SWIG_fail;
41429 }
41430 resultobj = SWIG_Py_Void();
41431 return resultobj;
41432 fail:
41433 return NULL;
41434 }
41435
41436
41437 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41438 PyObject *resultobj = 0;
41439 wxMenu *arg1 = (wxMenu *) 0 ;
41440 wxMenuBar *result = 0 ;
41441 void *argp1 = 0 ;
41442 int res1 = 0 ;
41443 PyObject *swig_obj[1] ;
41444
41445 if (!args) SWIG_fail;
41446 swig_obj[0] = args;
41447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41448 if (!SWIG_IsOK(res1)) {
41449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41450 }
41451 arg1 = reinterpret_cast< wxMenu * >(argp1);
41452 {
41453 PyThreadState* __tstate = wxPyBeginAllowThreads();
41454 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41455 wxPyEndAllowThreads(__tstate);
41456 if (PyErr_Occurred()) SWIG_fail;
41457 }
41458 {
41459 resultobj = wxPyMake_wxObject(result, (bool)0);
41460 }
41461 return resultobj;
41462 fail:
41463 return NULL;
41464 }
41465
41466
41467 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41468 PyObject *resultobj = 0;
41469 wxMenu *arg1 = (wxMenu *) 0 ;
41470 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41471 void *argp1 = 0 ;
41472 int res1 = 0 ;
41473 void *argp2 = 0 ;
41474 int res2 = 0 ;
41475 PyObject * obj0 = 0 ;
41476 PyObject * obj1 = 0 ;
41477 char * kwnames[] = {
41478 (char *) "self",(char *) "menubar", NULL
41479 };
41480
41481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41483 if (!SWIG_IsOK(res1)) {
41484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41485 }
41486 arg1 = reinterpret_cast< wxMenu * >(argp1);
41487 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41488 if (!SWIG_IsOK(res2)) {
41489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41490 }
41491 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41492 {
41493 PyThreadState* __tstate = wxPyBeginAllowThreads();
41494 (arg1)->Attach(arg2);
41495 wxPyEndAllowThreads(__tstate);
41496 if (PyErr_Occurred()) SWIG_fail;
41497 }
41498 resultobj = SWIG_Py_Void();
41499 return resultobj;
41500 fail:
41501 return NULL;
41502 }
41503
41504
41505 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41506 PyObject *resultobj = 0;
41507 wxMenu *arg1 = (wxMenu *) 0 ;
41508 void *argp1 = 0 ;
41509 int res1 = 0 ;
41510 PyObject *swig_obj[1] ;
41511
41512 if (!args) SWIG_fail;
41513 swig_obj[0] = args;
41514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41515 if (!SWIG_IsOK(res1)) {
41516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41517 }
41518 arg1 = reinterpret_cast< wxMenu * >(argp1);
41519 {
41520 PyThreadState* __tstate = wxPyBeginAllowThreads();
41521 (arg1)->Detach();
41522 wxPyEndAllowThreads(__tstate);
41523 if (PyErr_Occurred()) SWIG_fail;
41524 }
41525 resultobj = SWIG_Py_Void();
41526 return resultobj;
41527 fail:
41528 return NULL;
41529 }
41530
41531
41532 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41533 PyObject *resultobj = 0;
41534 wxMenu *arg1 = (wxMenu *) 0 ;
41535 bool result;
41536 void *argp1 = 0 ;
41537 int res1 = 0 ;
41538 PyObject *swig_obj[1] ;
41539
41540 if (!args) SWIG_fail;
41541 swig_obj[0] = args;
41542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41543 if (!SWIG_IsOK(res1)) {
41544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41545 }
41546 arg1 = reinterpret_cast< wxMenu * >(argp1);
41547 {
41548 PyThreadState* __tstate = wxPyBeginAllowThreads();
41549 result = (bool)((wxMenu const *)arg1)->IsAttached();
41550 wxPyEndAllowThreads(__tstate);
41551 if (PyErr_Occurred()) SWIG_fail;
41552 }
41553 {
41554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41555 }
41556 return resultobj;
41557 fail:
41558 return NULL;
41559 }
41560
41561
41562 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41563 PyObject *resultobj = 0;
41564 wxMenu *arg1 = (wxMenu *) 0 ;
41565 wxMenu *arg2 = (wxMenu *) 0 ;
41566 void *argp1 = 0 ;
41567 int res1 = 0 ;
41568 void *argp2 = 0 ;
41569 int res2 = 0 ;
41570 PyObject * obj0 = 0 ;
41571 PyObject * obj1 = 0 ;
41572 char * kwnames[] = {
41573 (char *) "self",(char *) "parent", NULL
41574 };
41575
41576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41578 if (!SWIG_IsOK(res1)) {
41579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41580 }
41581 arg1 = reinterpret_cast< wxMenu * >(argp1);
41582 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41583 if (!SWIG_IsOK(res2)) {
41584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41585 }
41586 arg2 = reinterpret_cast< wxMenu * >(argp2);
41587 {
41588 PyThreadState* __tstate = wxPyBeginAllowThreads();
41589 (arg1)->SetParent(arg2);
41590 wxPyEndAllowThreads(__tstate);
41591 if (PyErr_Occurred()) SWIG_fail;
41592 }
41593 resultobj = SWIG_Py_Void();
41594 return resultobj;
41595 fail:
41596 return NULL;
41597 }
41598
41599
41600 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41601 PyObject *resultobj = 0;
41602 wxMenu *arg1 = (wxMenu *) 0 ;
41603 wxMenu *result = 0 ;
41604 void *argp1 = 0 ;
41605 int res1 = 0 ;
41606 PyObject *swig_obj[1] ;
41607
41608 if (!args) SWIG_fail;
41609 swig_obj[0] = args;
41610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41611 if (!SWIG_IsOK(res1)) {
41612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41613 }
41614 arg1 = reinterpret_cast< wxMenu * >(argp1);
41615 {
41616 PyThreadState* __tstate = wxPyBeginAllowThreads();
41617 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41618 wxPyEndAllowThreads(__tstate);
41619 if (PyErr_Occurred()) SWIG_fail;
41620 }
41621 {
41622 resultobj = wxPyMake_wxObject(result, 0);
41623 }
41624 return resultobj;
41625 fail:
41626 return NULL;
41627 }
41628
41629
41630 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41631 PyObject *obj;
41632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41633 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41634 return SWIG_Py_Void();
41635 }
41636
41637 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41638 return SWIG_Python_InitShadowInstance(args);
41639 }
41640
41641 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41642 PyObject *resultobj = 0;
41643 long arg1 = (long) 0 ;
41644 wxMenuBar *result = 0 ;
41645 long val1 ;
41646 int ecode1 = 0 ;
41647 PyObject * obj0 = 0 ;
41648 char * kwnames[] = {
41649 (char *) "style", NULL
41650 };
41651
41652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41653 if (obj0) {
41654 ecode1 = SWIG_AsVal_long(obj0, &val1);
41655 if (!SWIG_IsOK(ecode1)) {
41656 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41657 }
41658 arg1 = static_cast< long >(val1);
41659 }
41660 {
41661 if (!wxPyCheckForApp()) SWIG_fail;
41662 PyThreadState* __tstate = wxPyBeginAllowThreads();
41663 result = (wxMenuBar *)new wxMenuBar(arg1);
41664 wxPyEndAllowThreads(__tstate);
41665 if (PyErr_Occurred()) SWIG_fail;
41666 }
41667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41668 return resultobj;
41669 fail:
41670 return NULL;
41671 }
41672
41673
41674 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41675 PyObject *resultobj = 0;
41676 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41677 wxMenu *arg2 = (wxMenu *) 0 ;
41678 wxString *arg3 = 0 ;
41679 bool result;
41680 void *argp1 = 0 ;
41681 int res1 = 0 ;
41682 void *argp2 = 0 ;
41683 int res2 = 0 ;
41684 bool temp3 = false ;
41685 PyObject * obj0 = 0 ;
41686 PyObject * obj1 = 0 ;
41687 PyObject * obj2 = 0 ;
41688 char * kwnames[] = {
41689 (char *) "self",(char *) "menu",(char *) "title", NULL
41690 };
41691
41692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41694 if (!SWIG_IsOK(res1)) {
41695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41696 }
41697 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41698 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41699 if (!SWIG_IsOK(res2)) {
41700 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41701 }
41702 arg2 = reinterpret_cast< wxMenu * >(argp2);
41703 {
41704 arg3 = wxString_in_helper(obj2);
41705 if (arg3 == NULL) SWIG_fail;
41706 temp3 = true;
41707 }
41708 {
41709 PyThreadState* __tstate = wxPyBeginAllowThreads();
41710 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41711 wxPyEndAllowThreads(__tstate);
41712 if (PyErr_Occurred()) SWIG_fail;
41713 }
41714 {
41715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41716 }
41717 {
41718 if (temp3)
41719 delete arg3;
41720 }
41721 return resultobj;
41722 fail:
41723 {
41724 if (temp3)
41725 delete arg3;
41726 }
41727 return NULL;
41728 }
41729
41730
41731 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41732 PyObject *resultobj = 0;
41733 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41734 size_t arg2 ;
41735 wxMenu *arg3 = (wxMenu *) 0 ;
41736 wxString *arg4 = 0 ;
41737 bool result;
41738 void *argp1 = 0 ;
41739 int res1 = 0 ;
41740 size_t val2 ;
41741 int ecode2 = 0 ;
41742 void *argp3 = 0 ;
41743 int res3 = 0 ;
41744 bool temp4 = false ;
41745 PyObject * obj0 = 0 ;
41746 PyObject * obj1 = 0 ;
41747 PyObject * obj2 = 0 ;
41748 PyObject * obj3 = 0 ;
41749 char * kwnames[] = {
41750 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41751 };
41752
41753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41755 if (!SWIG_IsOK(res1)) {
41756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41757 }
41758 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41759 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41760 if (!SWIG_IsOK(ecode2)) {
41761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41762 }
41763 arg2 = static_cast< size_t >(val2);
41764 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41765 if (!SWIG_IsOK(res3)) {
41766 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41767 }
41768 arg3 = reinterpret_cast< wxMenu * >(argp3);
41769 {
41770 arg4 = wxString_in_helper(obj3);
41771 if (arg4 == NULL) SWIG_fail;
41772 temp4 = true;
41773 }
41774 {
41775 PyThreadState* __tstate = wxPyBeginAllowThreads();
41776 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41777 wxPyEndAllowThreads(__tstate);
41778 if (PyErr_Occurred()) SWIG_fail;
41779 }
41780 {
41781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41782 }
41783 {
41784 if (temp4)
41785 delete arg4;
41786 }
41787 return resultobj;
41788 fail:
41789 {
41790 if (temp4)
41791 delete arg4;
41792 }
41793 return NULL;
41794 }
41795
41796
41797 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41798 PyObject *resultobj = 0;
41799 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41800 size_t result;
41801 void *argp1 = 0 ;
41802 int res1 = 0 ;
41803 PyObject *swig_obj[1] ;
41804
41805 if (!args) SWIG_fail;
41806 swig_obj[0] = args;
41807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41808 if (!SWIG_IsOK(res1)) {
41809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41810 }
41811 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41812 {
41813 PyThreadState* __tstate = wxPyBeginAllowThreads();
41814 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41815 wxPyEndAllowThreads(__tstate);
41816 if (PyErr_Occurred()) SWIG_fail;
41817 }
41818 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41819 return resultobj;
41820 fail:
41821 return NULL;
41822 }
41823
41824
41825 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41826 PyObject *resultobj = 0;
41827 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41828 size_t arg2 ;
41829 wxMenu *result = 0 ;
41830 void *argp1 = 0 ;
41831 int res1 = 0 ;
41832 size_t val2 ;
41833 int ecode2 = 0 ;
41834 PyObject * obj0 = 0 ;
41835 PyObject * obj1 = 0 ;
41836 char * kwnames[] = {
41837 (char *) "self",(char *) "pos", NULL
41838 };
41839
41840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41842 if (!SWIG_IsOK(res1)) {
41843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41844 }
41845 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41846 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41847 if (!SWIG_IsOK(ecode2)) {
41848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41849 }
41850 arg2 = static_cast< size_t >(val2);
41851 {
41852 PyThreadState* __tstate = wxPyBeginAllowThreads();
41853 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41854 wxPyEndAllowThreads(__tstate);
41855 if (PyErr_Occurred()) SWIG_fail;
41856 }
41857 {
41858 resultobj = wxPyMake_wxObject(result, 0);
41859 }
41860 return resultobj;
41861 fail:
41862 return NULL;
41863 }
41864
41865
41866 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41867 PyObject *resultobj = 0;
41868 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41869 size_t arg2 ;
41870 wxMenu *arg3 = (wxMenu *) 0 ;
41871 wxString *arg4 = 0 ;
41872 wxMenu *result = 0 ;
41873 void *argp1 = 0 ;
41874 int res1 = 0 ;
41875 size_t val2 ;
41876 int ecode2 = 0 ;
41877 void *argp3 = 0 ;
41878 int res3 = 0 ;
41879 bool temp4 = false ;
41880 PyObject * obj0 = 0 ;
41881 PyObject * obj1 = 0 ;
41882 PyObject * obj2 = 0 ;
41883 PyObject * obj3 = 0 ;
41884 char * kwnames[] = {
41885 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41886 };
41887
41888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41890 if (!SWIG_IsOK(res1)) {
41891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41892 }
41893 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41894 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41895 if (!SWIG_IsOK(ecode2)) {
41896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41897 }
41898 arg2 = static_cast< size_t >(val2);
41899 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41900 if (!SWIG_IsOK(res3)) {
41901 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41902 }
41903 arg3 = reinterpret_cast< wxMenu * >(argp3);
41904 {
41905 arg4 = wxString_in_helper(obj3);
41906 if (arg4 == NULL) SWIG_fail;
41907 temp4 = true;
41908 }
41909 {
41910 PyThreadState* __tstate = wxPyBeginAllowThreads();
41911 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41912 wxPyEndAllowThreads(__tstate);
41913 if (PyErr_Occurred()) SWIG_fail;
41914 }
41915 {
41916 resultobj = wxPyMake_wxObject(result, 0);
41917 }
41918 {
41919 if (temp4)
41920 delete arg4;
41921 }
41922 return resultobj;
41923 fail:
41924 {
41925 if (temp4)
41926 delete arg4;
41927 }
41928 return NULL;
41929 }
41930
41931
41932 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41933 PyObject *resultobj = 0;
41934 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41935 size_t arg2 ;
41936 wxMenu *result = 0 ;
41937 void *argp1 = 0 ;
41938 int res1 = 0 ;
41939 size_t val2 ;
41940 int ecode2 = 0 ;
41941 PyObject * obj0 = 0 ;
41942 PyObject * obj1 = 0 ;
41943 char * kwnames[] = {
41944 (char *) "self",(char *) "pos", NULL
41945 };
41946
41947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41949 if (!SWIG_IsOK(res1)) {
41950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41951 }
41952 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41953 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41954 if (!SWIG_IsOK(ecode2)) {
41955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41956 }
41957 arg2 = static_cast< size_t >(val2);
41958 {
41959 PyThreadState* __tstate = wxPyBeginAllowThreads();
41960 result = (wxMenu *)(arg1)->Remove(arg2);
41961 wxPyEndAllowThreads(__tstate);
41962 if (PyErr_Occurred()) SWIG_fail;
41963 }
41964 {
41965 resultobj = wxPyMake_wxObject(result, 0);
41966 }
41967 return resultobj;
41968 fail:
41969 return NULL;
41970 }
41971
41972
41973 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41974 PyObject *resultobj = 0;
41975 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41976 size_t arg2 ;
41977 bool arg3 ;
41978 void *argp1 = 0 ;
41979 int res1 = 0 ;
41980 size_t val2 ;
41981 int ecode2 = 0 ;
41982 bool val3 ;
41983 int ecode3 = 0 ;
41984 PyObject * obj0 = 0 ;
41985 PyObject * obj1 = 0 ;
41986 PyObject * obj2 = 0 ;
41987 char * kwnames[] = {
41988 (char *) "self",(char *) "pos",(char *) "enable", NULL
41989 };
41990
41991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41993 if (!SWIG_IsOK(res1)) {
41994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41995 }
41996 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41997 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41998 if (!SWIG_IsOK(ecode2)) {
41999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42000 }
42001 arg2 = static_cast< size_t >(val2);
42002 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42003 if (!SWIG_IsOK(ecode3)) {
42004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42005 }
42006 arg3 = static_cast< bool >(val3);
42007 {
42008 PyThreadState* __tstate = wxPyBeginAllowThreads();
42009 (arg1)->EnableTop(arg2,arg3);
42010 wxPyEndAllowThreads(__tstate);
42011 if (PyErr_Occurred()) SWIG_fail;
42012 }
42013 resultobj = SWIG_Py_Void();
42014 return resultobj;
42015 fail:
42016 return NULL;
42017 }
42018
42019
42020 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42021 PyObject *resultobj = 0;
42022 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42023 size_t arg2 ;
42024 bool result;
42025 void *argp1 = 0 ;
42026 int res1 = 0 ;
42027 size_t val2 ;
42028 int ecode2 = 0 ;
42029 PyObject * obj0 = 0 ;
42030 PyObject * obj1 = 0 ;
42031 char * kwnames[] = {
42032 (char *) "self",(char *) "pos", NULL
42033 };
42034
42035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42037 if (!SWIG_IsOK(res1)) {
42038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42039 }
42040 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42041 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42042 if (!SWIG_IsOK(ecode2)) {
42043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42044 }
42045 arg2 = static_cast< size_t >(val2);
42046 {
42047 PyThreadState* __tstate = wxPyBeginAllowThreads();
42048 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42049 wxPyEndAllowThreads(__tstate);
42050 if (PyErr_Occurred()) SWIG_fail;
42051 }
42052 {
42053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42054 }
42055 return resultobj;
42056 fail:
42057 return NULL;
42058 }
42059
42060
42061 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42062 PyObject *resultobj = 0;
42063 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42064 size_t arg2 ;
42065 wxString *arg3 = 0 ;
42066 void *argp1 = 0 ;
42067 int res1 = 0 ;
42068 size_t val2 ;
42069 int ecode2 = 0 ;
42070 bool temp3 = false ;
42071 PyObject * obj0 = 0 ;
42072 PyObject * obj1 = 0 ;
42073 PyObject * obj2 = 0 ;
42074 char * kwnames[] = {
42075 (char *) "self",(char *) "pos",(char *) "label", NULL
42076 };
42077
42078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42080 if (!SWIG_IsOK(res1)) {
42081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42082 }
42083 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42084 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42085 if (!SWIG_IsOK(ecode2)) {
42086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42087 }
42088 arg2 = static_cast< size_t >(val2);
42089 {
42090 arg3 = wxString_in_helper(obj2);
42091 if (arg3 == NULL) SWIG_fail;
42092 temp3 = true;
42093 }
42094 {
42095 PyThreadState* __tstate = wxPyBeginAllowThreads();
42096 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42097 wxPyEndAllowThreads(__tstate);
42098 if (PyErr_Occurred()) SWIG_fail;
42099 }
42100 resultobj = SWIG_Py_Void();
42101 {
42102 if (temp3)
42103 delete arg3;
42104 }
42105 return resultobj;
42106 fail:
42107 {
42108 if (temp3)
42109 delete arg3;
42110 }
42111 return NULL;
42112 }
42113
42114
42115 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42116 PyObject *resultobj = 0;
42117 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42118 size_t arg2 ;
42119 wxString result;
42120 void *argp1 = 0 ;
42121 int res1 = 0 ;
42122 size_t val2 ;
42123 int ecode2 = 0 ;
42124 PyObject * obj0 = 0 ;
42125 PyObject * obj1 = 0 ;
42126 char * kwnames[] = {
42127 (char *) "self",(char *) "pos", NULL
42128 };
42129
42130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42132 if (!SWIG_IsOK(res1)) {
42133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42134 }
42135 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42136 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42137 if (!SWIG_IsOK(ecode2)) {
42138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42139 }
42140 arg2 = static_cast< size_t >(val2);
42141 {
42142 PyThreadState* __tstate = wxPyBeginAllowThreads();
42143 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42144 wxPyEndAllowThreads(__tstate);
42145 if (PyErr_Occurred()) SWIG_fail;
42146 }
42147 {
42148 #if wxUSE_UNICODE
42149 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42150 #else
42151 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42152 #endif
42153 }
42154 return resultobj;
42155 fail:
42156 return NULL;
42157 }
42158
42159
42160 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42161 PyObject *resultobj = 0;
42162 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42163 wxString *arg2 = 0 ;
42164 wxString *arg3 = 0 ;
42165 int result;
42166 void *argp1 = 0 ;
42167 int res1 = 0 ;
42168 bool temp2 = false ;
42169 bool temp3 = false ;
42170 PyObject * obj0 = 0 ;
42171 PyObject * obj1 = 0 ;
42172 PyObject * obj2 = 0 ;
42173 char * kwnames[] = {
42174 (char *) "self",(char *) "menu",(char *) "item", NULL
42175 };
42176
42177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42179 if (!SWIG_IsOK(res1)) {
42180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42181 }
42182 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42183 {
42184 arg2 = wxString_in_helper(obj1);
42185 if (arg2 == NULL) SWIG_fail;
42186 temp2 = true;
42187 }
42188 {
42189 arg3 = wxString_in_helper(obj2);
42190 if (arg3 == NULL) SWIG_fail;
42191 temp3 = true;
42192 }
42193 {
42194 PyThreadState* __tstate = wxPyBeginAllowThreads();
42195 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42196 wxPyEndAllowThreads(__tstate);
42197 if (PyErr_Occurred()) SWIG_fail;
42198 }
42199 resultobj = SWIG_From_int(static_cast< int >(result));
42200 {
42201 if (temp2)
42202 delete arg2;
42203 }
42204 {
42205 if (temp3)
42206 delete arg3;
42207 }
42208 return resultobj;
42209 fail:
42210 {
42211 if (temp2)
42212 delete arg2;
42213 }
42214 {
42215 if (temp3)
42216 delete arg3;
42217 }
42218 return NULL;
42219 }
42220
42221
42222 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42223 PyObject *resultobj = 0;
42224 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42225 int arg2 ;
42226 wxMenuItem *result = 0 ;
42227 void *argp1 = 0 ;
42228 int res1 = 0 ;
42229 int val2 ;
42230 int ecode2 = 0 ;
42231 PyObject * obj0 = 0 ;
42232 PyObject * obj1 = 0 ;
42233 char * kwnames[] = {
42234 (char *) "self",(char *) "id", NULL
42235 };
42236
42237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42239 if (!SWIG_IsOK(res1)) {
42240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42241 }
42242 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42243 ecode2 = SWIG_AsVal_int(obj1, &val2);
42244 if (!SWIG_IsOK(ecode2)) {
42245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42246 }
42247 arg2 = static_cast< int >(val2);
42248 {
42249 PyThreadState* __tstate = wxPyBeginAllowThreads();
42250 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42251 wxPyEndAllowThreads(__tstate);
42252 if (PyErr_Occurred()) SWIG_fail;
42253 }
42254 {
42255 resultobj = wxPyMake_wxObject(result, (bool)0);
42256 }
42257 return resultobj;
42258 fail:
42259 return NULL;
42260 }
42261
42262
42263 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42264 PyObject *resultobj = 0;
42265 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42266 wxString *arg2 = 0 ;
42267 int result;
42268 void *argp1 = 0 ;
42269 int res1 = 0 ;
42270 bool temp2 = false ;
42271 PyObject * obj0 = 0 ;
42272 PyObject * obj1 = 0 ;
42273 char * kwnames[] = {
42274 (char *) "self",(char *) "title", NULL
42275 };
42276
42277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42279 if (!SWIG_IsOK(res1)) {
42280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42281 }
42282 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42283 {
42284 arg2 = wxString_in_helper(obj1);
42285 if (arg2 == NULL) SWIG_fail;
42286 temp2 = true;
42287 }
42288 {
42289 PyThreadState* __tstate = wxPyBeginAllowThreads();
42290 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42291 wxPyEndAllowThreads(__tstate);
42292 if (PyErr_Occurred()) SWIG_fail;
42293 }
42294 resultobj = SWIG_From_int(static_cast< int >(result));
42295 {
42296 if (temp2)
42297 delete arg2;
42298 }
42299 return resultobj;
42300 fail:
42301 {
42302 if (temp2)
42303 delete arg2;
42304 }
42305 return NULL;
42306 }
42307
42308
42309 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42310 PyObject *resultobj = 0;
42311 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42312 int arg2 ;
42313 bool arg3 ;
42314 void *argp1 = 0 ;
42315 int res1 = 0 ;
42316 int val2 ;
42317 int ecode2 = 0 ;
42318 bool val3 ;
42319 int ecode3 = 0 ;
42320 PyObject * obj0 = 0 ;
42321 PyObject * obj1 = 0 ;
42322 PyObject * obj2 = 0 ;
42323 char * kwnames[] = {
42324 (char *) "self",(char *) "id",(char *) "enable", NULL
42325 };
42326
42327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42329 if (!SWIG_IsOK(res1)) {
42330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42331 }
42332 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42333 ecode2 = SWIG_AsVal_int(obj1, &val2);
42334 if (!SWIG_IsOK(ecode2)) {
42335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42336 }
42337 arg2 = static_cast< int >(val2);
42338 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42339 if (!SWIG_IsOK(ecode3)) {
42340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42341 }
42342 arg3 = static_cast< bool >(val3);
42343 {
42344 PyThreadState* __tstate = wxPyBeginAllowThreads();
42345 (arg1)->Enable(arg2,arg3);
42346 wxPyEndAllowThreads(__tstate);
42347 if (PyErr_Occurred()) SWIG_fail;
42348 }
42349 resultobj = SWIG_Py_Void();
42350 return resultobj;
42351 fail:
42352 return NULL;
42353 }
42354
42355
42356 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42357 PyObject *resultobj = 0;
42358 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42359 int arg2 ;
42360 bool arg3 ;
42361 void *argp1 = 0 ;
42362 int res1 = 0 ;
42363 int val2 ;
42364 int ecode2 = 0 ;
42365 bool val3 ;
42366 int ecode3 = 0 ;
42367 PyObject * obj0 = 0 ;
42368 PyObject * obj1 = 0 ;
42369 PyObject * obj2 = 0 ;
42370 char * kwnames[] = {
42371 (char *) "self",(char *) "id",(char *) "check", NULL
42372 };
42373
42374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42376 if (!SWIG_IsOK(res1)) {
42377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42378 }
42379 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42380 ecode2 = SWIG_AsVal_int(obj1, &val2);
42381 if (!SWIG_IsOK(ecode2)) {
42382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42383 }
42384 arg2 = static_cast< int >(val2);
42385 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42386 if (!SWIG_IsOK(ecode3)) {
42387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
42388 }
42389 arg3 = static_cast< bool >(val3);
42390 {
42391 PyThreadState* __tstate = wxPyBeginAllowThreads();
42392 (arg1)->Check(arg2,arg3);
42393 wxPyEndAllowThreads(__tstate);
42394 if (PyErr_Occurred()) SWIG_fail;
42395 }
42396 resultobj = SWIG_Py_Void();
42397 return resultobj;
42398 fail:
42399 return NULL;
42400 }
42401
42402
42403 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42404 PyObject *resultobj = 0;
42405 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42406 int arg2 ;
42407 bool result;
42408 void *argp1 = 0 ;
42409 int res1 = 0 ;
42410 int val2 ;
42411 int ecode2 = 0 ;
42412 PyObject * obj0 = 0 ;
42413 PyObject * obj1 = 0 ;
42414 char * kwnames[] = {
42415 (char *) "self",(char *) "id", NULL
42416 };
42417
42418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42420 if (!SWIG_IsOK(res1)) {
42421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42422 }
42423 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42424 ecode2 = SWIG_AsVal_int(obj1, &val2);
42425 if (!SWIG_IsOK(ecode2)) {
42426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42427 }
42428 arg2 = static_cast< int >(val2);
42429 {
42430 PyThreadState* __tstate = wxPyBeginAllowThreads();
42431 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42432 wxPyEndAllowThreads(__tstate);
42433 if (PyErr_Occurred()) SWIG_fail;
42434 }
42435 {
42436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42437 }
42438 return resultobj;
42439 fail:
42440 return NULL;
42441 }
42442
42443
42444 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42445 PyObject *resultobj = 0;
42446 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42447 int arg2 ;
42448 bool result;
42449 void *argp1 = 0 ;
42450 int res1 = 0 ;
42451 int val2 ;
42452 int ecode2 = 0 ;
42453 PyObject * obj0 = 0 ;
42454 PyObject * obj1 = 0 ;
42455 char * kwnames[] = {
42456 (char *) "self",(char *) "id", NULL
42457 };
42458
42459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42461 if (!SWIG_IsOK(res1)) {
42462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42463 }
42464 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42465 ecode2 = SWIG_AsVal_int(obj1, &val2);
42466 if (!SWIG_IsOK(ecode2)) {
42467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42468 }
42469 arg2 = static_cast< int >(val2);
42470 {
42471 PyThreadState* __tstate = wxPyBeginAllowThreads();
42472 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42473 wxPyEndAllowThreads(__tstate);
42474 if (PyErr_Occurred()) SWIG_fail;
42475 }
42476 {
42477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42478 }
42479 return resultobj;
42480 fail:
42481 return NULL;
42482 }
42483
42484
42485 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42486 PyObject *resultobj = 0;
42487 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42488 int arg2 ;
42489 wxString *arg3 = 0 ;
42490 void *argp1 = 0 ;
42491 int res1 = 0 ;
42492 int val2 ;
42493 int ecode2 = 0 ;
42494 bool temp3 = false ;
42495 PyObject * obj0 = 0 ;
42496 PyObject * obj1 = 0 ;
42497 PyObject * obj2 = 0 ;
42498 char * kwnames[] = {
42499 (char *) "self",(char *) "id",(char *) "label", NULL
42500 };
42501
42502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42504 if (!SWIG_IsOK(res1)) {
42505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42506 }
42507 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42508 ecode2 = SWIG_AsVal_int(obj1, &val2);
42509 if (!SWIG_IsOK(ecode2)) {
42510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42511 }
42512 arg2 = static_cast< int >(val2);
42513 {
42514 arg3 = wxString_in_helper(obj2);
42515 if (arg3 == NULL) SWIG_fail;
42516 temp3 = true;
42517 }
42518 {
42519 PyThreadState* __tstate = wxPyBeginAllowThreads();
42520 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42521 wxPyEndAllowThreads(__tstate);
42522 if (PyErr_Occurred()) SWIG_fail;
42523 }
42524 resultobj = SWIG_Py_Void();
42525 {
42526 if (temp3)
42527 delete arg3;
42528 }
42529 return resultobj;
42530 fail:
42531 {
42532 if (temp3)
42533 delete arg3;
42534 }
42535 return NULL;
42536 }
42537
42538
42539 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42540 PyObject *resultobj = 0;
42541 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42542 int arg2 ;
42543 wxString result;
42544 void *argp1 = 0 ;
42545 int res1 = 0 ;
42546 int val2 ;
42547 int ecode2 = 0 ;
42548 PyObject * obj0 = 0 ;
42549 PyObject * obj1 = 0 ;
42550 char * kwnames[] = {
42551 (char *) "self",(char *) "id", NULL
42552 };
42553
42554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42556 if (!SWIG_IsOK(res1)) {
42557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42558 }
42559 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42560 ecode2 = SWIG_AsVal_int(obj1, &val2);
42561 if (!SWIG_IsOK(ecode2)) {
42562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42563 }
42564 arg2 = static_cast< int >(val2);
42565 {
42566 PyThreadState* __tstate = wxPyBeginAllowThreads();
42567 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42568 wxPyEndAllowThreads(__tstate);
42569 if (PyErr_Occurred()) SWIG_fail;
42570 }
42571 {
42572 #if wxUSE_UNICODE
42573 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42574 #else
42575 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42576 #endif
42577 }
42578 return resultobj;
42579 fail:
42580 return NULL;
42581 }
42582
42583
42584 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42585 PyObject *resultobj = 0;
42586 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42587 int arg2 ;
42588 wxString *arg3 = 0 ;
42589 void *argp1 = 0 ;
42590 int res1 = 0 ;
42591 int val2 ;
42592 int ecode2 = 0 ;
42593 bool temp3 = false ;
42594 PyObject * obj0 = 0 ;
42595 PyObject * obj1 = 0 ;
42596 PyObject * obj2 = 0 ;
42597 char * kwnames[] = {
42598 (char *) "self",(char *) "id",(char *) "helpString", NULL
42599 };
42600
42601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42603 if (!SWIG_IsOK(res1)) {
42604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42605 }
42606 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42607 ecode2 = SWIG_AsVal_int(obj1, &val2);
42608 if (!SWIG_IsOK(ecode2)) {
42609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42610 }
42611 arg2 = static_cast< int >(val2);
42612 {
42613 arg3 = wxString_in_helper(obj2);
42614 if (arg3 == NULL) SWIG_fail;
42615 temp3 = true;
42616 }
42617 {
42618 PyThreadState* __tstate = wxPyBeginAllowThreads();
42619 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42620 wxPyEndAllowThreads(__tstate);
42621 if (PyErr_Occurred()) SWIG_fail;
42622 }
42623 resultobj = SWIG_Py_Void();
42624 {
42625 if (temp3)
42626 delete arg3;
42627 }
42628 return resultobj;
42629 fail:
42630 {
42631 if (temp3)
42632 delete arg3;
42633 }
42634 return NULL;
42635 }
42636
42637
42638 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42639 PyObject *resultobj = 0;
42640 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42641 int arg2 ;
42642 wxString result;
42643 void *argp1 = 0 ;
42644 int res1 = 0 ;
42645 int val2 ;
42646 int ecode2 = 0 ;
42647 PyObject * obj0 = 0 ;
42648 PyObject * obj1 = 0 ;
42649 char * kwnames[] = {
42650 (char *) "self",(char *) "id", NULL
42651 };
42652
42653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42655 if (!SWIG_IsOK(res1)) {
42656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42657 }
42658 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42659 ecode2 = SWIG_AsVal_int(obj1, &val2);
42660 if (!SWIG_IsOK(ecode2)) {
42661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42662 }
42663 arg2 = static_cast< int >(val2);
42664 {
42665 PyThreadState* __tstate = wxPyBeginAllowThreads();
42666 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42667 wxPyEndAllowThreads(__tstate);
42668 if (PyErr_Occurred()) SWIG_fail;
42669 }
42670 {
42671 #if wxUSE_UNICODE
42672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42673 #else
42674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42675 #endif
42676 }
42677 return resultobj;
42678 fail:
42679 return NULL;
42680 }
42681
42682
42683 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42684 PyObject *resultobj = 0;
42685 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42686 wxFrame *result = 0 ;
42687 void *argp1 = 0 ;
42688 int res1 = 0 ;
42689 PyObject *swig_obj[1] ;
42690
42691 if (!args) SWIG_fail;
42692 swig_obj[0] = args;
42693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42694 if (!SWIG_IsOK(res1)) {
42695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42696 }
42697 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42698 {
42699 PyThreadState* __tstate = wxPyBeginAllowThreads();
42700 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42701 wxPyEndAllowThreads(__tstate);
42702 if (PyErr_Occurred()) SWIG_fail;
42703 }
42704 {
42705 resultobj = wxPyMake_wxObject(result, (bool)0);
42706 }
42707 return resultobj;
42708 fail:
42709 return NULL;
42710 }
42711
42712
42713 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42714 PyObject *resultobj = 0;
42715 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42716 bool result;
42717 void *argp1 = 0 ;
42718 int res1 = 0 ;
42719 PyObject *swig_obj[1] ;
42720
42721 if (!args) SWIG_fail;
42722 swig_obj[0] = args;
42723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42724 if (!SWIG_IsOK(res1)) {
42725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42726 }
42727 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42728 {
42729 PyThreadState* __tstate = wxPyBeginAllowThreads();
42730 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42731 wxPyEndAllowThreads(__tstate);
42732 if (PyErr_Occurred()) SWIG_fail;
42733 }
42734 {
42735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42736 }
42737 return resultobj;
42738 fail:
42739 return NULL;
42740 }
42741
42742
42743 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42744 PyObject *resultobj = 0;
42745 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42746 wxFrame *arg2 = (wxFrame *) 0 ;
42747 void *argp1 = 0 ;
42748 int res1 = 0 ;
42749 void *argp2 = 0 ;
42750 int res2 = 0 ;
42751 PyObject * obj0 = 0 ;
42752 PyObject * obj1 = 0 ;
42753 char * kwnames[] = {
42754 (char *) "self",(char *) "frame", NULL
42755 };
42756
42757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42759 if (!SWIG_IsOK(res1)) {
42760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42761 }
42762 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42763 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42764 if (!SWIG_IsOK(res2)) {
42765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42766 }
42767 arg2 = reinterpret_cast< wxFrame * >(argp2);
42768 {
42769 PyThreadState* __tstate = wxPyBeginAllowThreads();
42770 (arg1)->Attach(arg2);
42771 wxPyEndAllowThreads(__tstate);
42772 if (PyErr_Occurred()) SWIG_fail;
42773 }
42774 resultobj = SWIG_Py_Void();
42775 return resultobj;
42776 fail:
42777 return NULL;
42778 }
42779
42780
42781 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42782 PyObject *resultobj = 0;
42783 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42784 void *argp1 = 0 ;
42785 int res1 = 0 ;
42786 PyObject *swig_obj[1] ;
42787
42788 if (!args) SWIG_fail;
42789 swig_obj[0] = args;
42790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42791 if (!SWIG_IsOK(res1)) {
42792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42793 }
42794 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42795 {
42796 PyThreadState* __tstate = wxPyBeginAllowThreads();
42797 (arg1)->Detach();
42798 wxPyEndAllowThreads(__tstate);
42799 if (PyErr_Occurred()) SWIG_fail;
42800 }
42801 resultobj = SWIG_Py_Void();
42802 return resultobj;
42803 fail:
42804 return NULL;
42805 }
42806
42807
42808 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42809 PyObject *resultobj = 0;
42810 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42811 void *argp1 = 0 ;
42812 int res1 = 0 ;
42813 PyObject *swig_obj[1] ;
42814
42815 if (!args) SWIG_fail;
42816 swig_obj[0] = args;
42817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42818 if (!SWIG_IsOK(res1)) {
42819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42820 }
42821 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42822 {
42823 PyThreadState* __tstate = wxPyBeginAllowThreads();
42824 (arg1)->UpdateMenus();
42825 wxPyEndAllowThreads(__tstate);
42826 if (PyErr_Occurred()) SWIG_fail;
42827 }
42828 resultobj = SWIG_Py_Void();
42829 return resultobj;
42830 fail:
42831 return NULL;
42832 }
42833
42834
42835 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42836 PyObject *resultobj = 0;
42837 bool arg1 ;
42838 bool val1 ;
42839 int ecode1 = 0 ;
42840 PyObject * obj0 = 0 ;
42841 char * kwnames[] = {
42842 (char *) "enable", NULL
42843 };
42844
42845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42846 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42847 if (!SWIG_IsOK(ecode1)) {
42848 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42849 }
42850 arg1 = static_cast< bool >(val1);
42851 {
42852 PyThreadState* __tstate = wxPyBeginAllowThreads();
42853 wxMenuBar::SetAutoWindowMenu(arg1);
42854 wxPyEndAllowThreads(__tstate);
42855 if (PyErr_Occurred()) SWIG_fail;
42856 }
42857 resultobj = SWIG_Py_Void();
42858 return resultobj;
42859 fail:
42860 return NULL;
42861 }
42862
42863
42864 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42865 PyObject *resultobj = 0;
42866 bool result;
42867
42868 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42869 {
42870 PyThreadState* __tstate = wxPyBeginAllowThreads();
42871 result = (bool)wxMenuBar::GetAutoWindowMenu();
42872 wxPyEndAllowThreads(__tstate);
42873 if (PyErr_Occurred()) SWIG_fail;
42874 }
42875 {
42876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42877 }
42878 return resultobj;
42879 fail:
42880 return NULL;
42881 }
42882
42883
42884 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42885 PyObject *obj;
42886 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42887 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42888 return SWIG_Py_Void();
42889 }
42890
42891 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42892 return SWIG_Python_InitShadowInstance(args);
42893 }
42894
42895 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42896 PyObject *resultobj = 0;
42897 wxMenu *arg1 = (wxMenu *) NULL ;
42898 int arg2 = (int) wxID_ANY ;
42899 wxString const &arg3_defvalue = wxPyEmptyString ;
42900 wxString *arg3 = (wxString *) &arg3_defvalue ;
42901 wxString const &arg4_defvalue = wxPyEmptyString ;
42902 wxString *arg4 = (wxString *) &arg4_defvalue ;
42903 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42904 wxMenu *arg6 = (wxMenu *) NULL ;
42905 wxMenuItem *result = 0 ;
42906 void *argp1 = 0 ;
42907 int res1 = 0 ;
42908 int val2 ;
42909 int ecode2 = 0 ;
42910 bool temp3 = false ;
42911 bool temp4 = false ;
42912 int val5 ;
42913 int ecode5 = 0 ;
42914 void *argp6 = 0 ;
42915 int res6 = 0 ;
42916 PyObject * obj0 = 0 ;
42917 PyObject * obj1 = 0 ;
42918 PyObject * obj2 = 0 ;
42919 PyObject * obj3 = 0 ;
42920 PyObject * obj4 = 0 ;
42921 PyObject * obj5 = 0 ;
42922 char * kwnames[] = {
42923 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42924 };
42925
42926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42927 if (obj0) {
42928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42929 if (!SWIG_IsOK(res1)) {
42930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42931 }
42932 arg1 = reinterpret_cast< wxMenu * >(argp1);
42933 }
42934 if (obj1) {
42935 ecode2 = SWIG_AsVal_int(obj1, &val2);
42936 if (!SWIG_IsOK(ecode2)) {
42937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42938 }
42939 arg2 = static_cast< int >(val2);
42940 }
42941 if (obj2) {
42942 {
42943 arg3 = wxString_in_helper(obj2);
42944 if (arg3 == NULL) SWIG_fail;
42945 temp3 = true;
42946 }
42947 }
42948 if (obj3) {
42949 {
42950 arg4 = wxString_in_helper(obj3);
42951 if (arg4 == NULL) SWIG_fail;
42952 temp4 = true;
42953 }
42954 }
42955 if (obj4) {
42956 ecode5 = SWIG_AsVal_int(obj4, &val5);
42957 if (!SWIG_IsOK(ecode5)) {
42958 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42959 }
42960 arg5 = static_cast< wxItemKind >(val5);
42961 }
42962 if (obj5) {
42963 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42964 if (!SWIG_IsOK(res6)) {
42965 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42966 }
42967 arg6 = reinterpret_cast< wxMenu * >(argp6);
42968 }
42969 {
42970 PyThreadState* __tstate = wxPyBeginAllowThreads();
42971 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42972 wxPyEndAllowThreads(__tstate);
42973 if (PyErr_Occurred()) SWIG_fail;
42974 }
42975 {
42976 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42977 }
42978 {
42979 if (temp3)
42980 delete arg3;
42981 }
42982 {
42983 if (temp4)
42984 delete arg4;
42985 }
42986 return resultobj;
42987 fail:
42988 {
42989 if (temp3)
42990 delete arg3;
42991 }
42992 {
42993 if (temp4)
42994 delete arg4;
42995 }
42996 return NULL;
42997 }
42998
42999
43000 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43001 PyObject *resultobj = 0;
43002 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43003 void *argp1 = 0 ;
43004 int res1 = 0 ;
43005 PyObject *swig_obj[1] ;
43006
43007 if (!args) SWIG_fail;
43008 swig_obj[0] = args;
43009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43010 if (!SWIG_IsOK(res1)) {
43011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43012 }
43013 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43014 {
43015 PyThreadState* __tstate = wxPyBeginAllowThreads();
43016 delete arg1;
43017
43018 wxPyEndAllowThreads(__tstate);
43019 if (PyErr_Occurred()) SWIG_fail;
43020 }
43021 resultobj = SWIG_Py_Void();
43022 return resultobj;
43023 fail:
43024 return NULL;
43025 }
43026
43027
43028 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43029 PyObject *resultobj = 0;
43030 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43031 wxMenu *result = 0 ;
43032 void *argp1 = 0 ;
43033 int res1 = 0 ;
43034 PyObject *swig_obj[1] ;
43035
43036 if (!args) SWIG_fail;
43037 swig_obj[0] = args;
43038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43039 if (!SWIG_IsOK(res1)) {
43040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43041 }
43042 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43043 {
43044 PyThreadState* __tstate = wxPyBeginAllowThreads();
43045 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43046 wxPyEndAllowThreads(__tstate);
43047 if (PyErr_Occurred()) SWIG_fail;
43048 }
43049 {
43050 resultobj = wxPyMake_wxObject(result, 0);
43051 }
43052 return resultobj;
43053 fail:
43054 return NULL;
43055 }
43056
43057
43058 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43059 PyObject *resultobj = 0;
43060 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43061 wxMenu *arg2 = (wxMenu *) 0 ;
43062 void *argp1 = 0 ;
43063 int res1 = 0 ;
43064 void *argp2 = 0 ;
43065 int res2 = 0 ;
43066 PyObject * obj0 = 0 ;
43067 PyObject * obj1 = 0 ;
43068 char * kwnames[] = {
43069 (char *) "self",(char *) "menu", NULL
43070 };
43071
43072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43074 if (!SWIG_IsOK(res1)) {
43075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43076 }
43077 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43078 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43079 if (!SWIG_IsOK(res2)) {
43080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43081 }
43082 arg2 = reinterpret_cast< wxMenu * >(argp2);
43083 {
43084 PyThreadState* __tstate = wxPyBeginAllowThreads();
43085 (arg1)->SetMenu(arg2);
43086 wxPyEndAllowThreads(__tstate);
43087 if (PyErr_Occurred()) SWIG_fail;
43088 }
43089 resultobj = SWIG_Py_Void();
43090 return resultobj;
43091 fail:
43092 return NULL;
43093 }
43094
43095
43096 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43097 PyObject *resultobj = 0;
43098 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43099 int arg2 ;
43100 void *argp1 = 0 ;
43101 int res1 = 0 ;
43102 int val2 ;
43103 int ecode2 = 0 ;
43104 PyObject * obj0 = 0 ;
43105 PyObject * obj1 = 0 ;
43106 char * kwnames[] = {
43107 (char *) "self",(char *) "id", NULL
43108 };
43109
43110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43112 if (!SWIG_IsOK(res1)) {
43113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43114 }
43115 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43116 ecode2 = SWIG_AsVal_int(obj1, &val2);
43117 if (!SWIG_IsOK(ecode2)) {
43118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43119 }
43120 arg2 = static_cast< int >(val2);
43121 {
43122 PyThreadState* __tstate = wxPyBeginAllowThreads();
43123 (arg1)->SetId(arg2);
43124 wxPyEndAllowThreads(__tstate);
43125 if (PyErr_Occurred()) SWIG_fail;
43126 }
43127 resultobj = SWIG_Py_Void();
43128 return resultobj;
43129 fail:
43130 return NULL;
43131 }
43132
43133
43134 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43135 PyObject *resultobj = 0;
43136 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43137 int result;
43138 void *argp1 = 0 ;
43139 int res1 = 0 ;
43140 PyObject *swig_obj[1] ;
43141
43142 if (!args) SWIG_fail;
43143 swig_obj[0] = args;
43144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43145 if (!SWIG_IsOK(res1)) {
43146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43147 }
43148 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43149 {
43150 PyThreadState* __tstate = wxPyBeginAllowThreads();
43151 result = (int)((wxMenuItem const *)arg1)->GetId();
43152 wxPyEndAllowThreads(__tstate);
43153 if (PyErr_Occurred()) SWIG_fail;
43154 }
43155 resultobj = SWIG_From_int(static_cast< int >(result));
43156 return resultobj;
43157 fail:
43158 return NULL;
43159 }
43160
43161
43162 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43163 PyObject *resultobj = 0;
43164 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43165 bool result;
43166 void *argp1 = 0 ;
43167 int res1 = 0 ;
43168 PyObject *swig_obj[1] ;
43169
43170 if (!args) SWIG_fail;
43171 swig_obj[0] = args;
43172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43173 if (!SWIG_IsOK(res1)) {
43174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43175 }
43176 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43177 {
43178 PyThreadState* __tstate = wxPyBeginAllowThreads();
43179 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43180 wxPyEndAllowThreads(__tstate);
43181 if (PyErr_Occurred()) SWIG_fail;
43182 }
43183 {
43184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43185 }
43186 return resultobj;
43187 fail:
43188 return NULL;
43189 }
43190
43191
43192 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43193 PyObject *resultobj = 0;
43194 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43195 wxString *arg2 = 0 ;
43196 void *argp1 = 0 ;
43197 int res1 = 0 ;
43198 bool temp2 = false ;
43199 PyObject * obj0 = 0 ;
43200 PyObject * obj1 = 0 ;
43201 char * kwnames[] = {
43202 (char *) "self",(char *) "str", NULL
43203 };
43204
43205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43207 if (!SWIG_IsOK(res1)) {
43208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43209 }
43210 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43211 {
43212 arg2 = wxString_in_helper(obj1);
43213 if (arg2 == NULL) SWIG_fail;
43214 temp2 = true;
43215 }
43216 {
43217 PyThreadState* __tstate = wxPyBeginAllowThreads();
43218 (arg1)->SetText((wxString const &)*arg2);
43219 wxPyEndAllowThreads(__tstate);
43220 if (PyErr_Occurred()) SWIG_fail;
43221 }
43222 resultobj = SWIG_Py_Void();
43223 {
43224 if (temp2)
43225 delete arg2;
43226 }
43227 return resultobj;
43228 fail:
43229 {
43230 if (temp2)
43231 delete arg2;
43232 }
43233 return NULL;
43234 }
43235
43236
43237 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43238 PyObject *resultobj = 0;
43239 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43240 wxString result;
43241 void *argp1 = 0 ;
43242 int res1 = 0 ;
43243 PyObject *swig_obj[1] ;
43244
43245 if (!args) SWIG_fail;
43246 swig_obj[0] = args;
43247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43248 if (!SWIG_IsOK(res1)) {
43249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43250 }
43251 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43252 {
43253 PyThreadState* __tstate = wxPyBeginAllowThreads();
43254 result = ((wxMenuItem const *)arg1)->GetLabel();
43255 wxPyEndAllowThreads(__tstate);
43256 if (PyErr_Occurred()) SWIG_fail;
43257 }
43258 {
43259 #if wxUSE_UNICODE
43260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43261 #else
43262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43263 #endif
43264 }
43265 return resultobj;
43266 fail:
43267 return NULL;
43268 }
43269
43270
43271 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43272 PyObject *resultobj = 0;
43273 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43274 wxString *result = 0 ;
43275 void *argp1 = 0 ;
43276 int res1 = 0 ;
43277 PyObject *swig_obj[1] ;
43278
43279 if (!args) SWIG_fail;
43280 swig_obj[0] = args;
43281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43282 if (!SWIG_IsOK(res1)) {
43283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43284 }
43285 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43286 {
43287 PyThreadState* __tstate = wxPyBeginAllowThreads();
43288 {
43289 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43290 result = (wxString *) &_result_ref;
43291 }
43292 wxPyEndAllowThreads(__tstate);
43293 if (PyErr_Occurred()) SWIG_fail;
43294 }
43295 {
43296 #if wxUSE_UNICODE
43297 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43298 #else
43299 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43300 #endif
43301 }
43302 return resultobj;
43303 fail:
43304 return NULL;
43305 }
43306
43307
43308 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43309 PyObject *resultobj = 0;
43310 wxString *arg1 = 0 ;
43311 wxString result;
43312 bool temp1 = false ;
43313 PyObject * obj0 = 0 ;
43314 char * kwnames[] = {
43315 (char *) "text", NULL
43316 };
43317
43318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43319 {
43320 arg1 = wxString_in_helper(obj0);
43321 if (arg1 == NULL) SWIG_fail;
43322 temp1 = true;
43323 }
43324 {
43325 PyThreadState* __tstate = wxPyBeginAllowThreads();
43326 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43327 wxPyEndAllowThreads(__tstate);
43328 if (PyErr_Occurred()) SWIG_fail;
43329 }
43330 {
43331 #if wxUSE_UNICODE
43332 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43333 #else
43334 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43335 #endif
43336 }
43337 {
43338 if (temp1)
43339 delete arg1;
43340 }
43341 return resultobj;
43342 fail:
43343 {
43344 if (temp1)
43345 delete arg1;
43346 }
43347 return NULL;
43348 }
43349
43350
43351 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43352 PyObject *resultobj = 0;
43353 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43354 wxItemKind 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_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43364 }
43365 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43366 {
43367 PyThreadState* __tstate = wxPyBeginAllowThreads();
43368 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43369 wxPyEndAllowThreads(__tstate);
43370 if (PyErr_Occurred()) SWIG_fail;
43371 }
43372 resultobj = SWIG_From_int(static_cast< int >(result));
43373 return resultobj;
43374 fail:
43375 return NULL;
43376 }
43377
43378
43379 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43380 PyObject *resultobj = 0;
43381 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43382 wxItemKind arg2 ;
43383 void *argp1 = 0 ;
43384 int res1 = 0 ;
43385 int val2 ;
43386 int ecode2 = 0 ;
43387 PyObject * obj0 = 0 ;
43388 PyObject * obj1 = 0 ;
43389 char * kwnames[] = {
43390 (char *) "self",(char *) "kind", NULL
43391 };
43392
43393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
43394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43395 if (!SWIG_IsOK(res1)) {
43396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43397 }
43398 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43399 ecode2 = SWIG_AsVal_int(obj1, &val2);
43400 if (!SWIG_IsOK(ecode2)) {
43401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
43402 }
43403 arg2 = static_cast< wxItemKind >(val2);
43404 {
43405 PyThreadState* __tstate = wxPyBeginAllowThreads();
43406 (arg1)->SetKind(arg2);
43407 wxPyEndAllowThreads(__tstate);
43408 if (PyErr_Occurred()) SWIG_fail;
43409 }
43410 resultobj = SWIG_Py_Void();
43411 return resultobj;
43412 fail:
43413 return NULL;
43414 }
43415
43416
43417 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43418 PyObject *resultobj = 0;
43419 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43420 bool arg2 ;
43421 void *argp1 = 0 ;
43422 int res1 = 0 ;
43423 bool val2 ;
43424 int ecode2 = 0 ;
43425 PyObject * obj0 = 0 ;
43426 PyObject * obj1 = 0 ;
43427 char * kwnames[] = {
43428 (char *) "self",(char *) "checkable", NULL
43429 };
43430
43431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43433 if (!SWIG_IsOK(res1)) {
43434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43435 }
43436 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43437 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43438 if (!SWIG_IsOK(ecode2)) {
43439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43440 }
43441 arg2 = static_cast< bool >(val2);
43442 {
43443 PyThreadState* __tstate = wxPyBeginAllowThreads();
43444 (arg1)->SetCheckable(arg2);
43445 wxPyEndAllowThreads(__tstate);
43446 if (PyErr_Occurred()) SWIG_fail;
43447 }
43448 resultobj = SWIG_Py_Void();
43449 return resultobj;
43450 fail:
43451 return NULL;
43452 }
43453
43454
43455 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43456 PyObject *resultobj = 0;
43457 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43458 bool result;
43459 void *argp1 = 0 ;
43460 int res1 = 0 ;
43461 PyObject *swig_obj[1] ;
43462
43463 if (!args) SWIG_fail;
43464 swig_obj[0] = args;
43465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43466 if (!SWIG_IsOK(res1)) {
43467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43468 }
43469 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43470 {
43471 PyThreadState* __tstate = wxPyBeginAllowThreads();
43472 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43473 wxPyEndAllowThreads(__tstate);
43474 if (PyErr_Occurred()) SWIG_fail;
43475 }
43476 {
43477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43478 }
43479 return resultobj;
43480 fail:
43481 return NULL;
43482 }
43483
43484
43485 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43486 PyObject *resultobj = 0;
43487 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43488 bool result;
43489 void *argp1 = 0 ;
43490 int res1 = 0 ;
43491 PyObject *swig_obj[1] ;
43492
43493 if (!args) SWIG_fail;
43494 swig_obj[0] = args;
43495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43496 if (!SWIG_IsOK(res1)) {
43497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43498 }
43499 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43500 {
43501 PyThreadState* __tstate = wxPyBeginAllowThreads();
43502 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43503 wxPyEndAllowThreads(__tstate);
43504 if (PyErr_Occurred()) SWIG_fail;
43505 }
43506 {
43507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43508 }
43509 return resultobj;
43510 fail:
43511 return NULL;
43512 }
43513
43514
43515 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43516 PyObject *resultobj = 0;
43517 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43518 wxMenu *arg2 = (wxMenu *) 0 ;
43519 void *argp1 = 0 ;
43520 int res1 = 0 ;
43521 void *argp2 = 0 ;
43522 int res2 = 0 ;
43523 PyObject * obj0 = 0 ;
43524 PyObject * obj1 = 0 ;
43525 char * kwnames[] = {
43526 (char *) "self",(char *) "menu", NULL
43527 };
43528
43529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43531 if (!SWIG_IsOK(res1)) {
43532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43533 }
43534 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43535 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43536 if (!SWIG_IsOK(res2)) {
43537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43538 }
43539 arg2 = reinterpret_cast< wxMenu * >(argp2);
43540 {
43541 PyThreadState* __tstate = wxPyBeginAllowThreads();
43542 (arg1)->SetSubMenu(arg2);
43543 wxPyEndAllowThreads(__tstate);
43544 if (PyErr_Occurred()) SWIG_fail;
43545 }
43546 resultobj = SWIG_Py_Void();
43547 return resultobj;
43548 fail:
43549 return NULL;
43550 }
43551
43552
43553 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43554 PyObject *resultobj = 0;
43555 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43556 wxMenu *result = 0 ;
43557 void *argp1 = 0 ;
43558 int res1 = 0 ;
43559 PyObject *swig_obj[1] ;
43560
43561 if (!args) SWIG_fail;
43562 swig_obj[0] = args;
43563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43564 if (!SWIG_IsOK(res1)) {
43565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43566 }
43567 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43568 {
43569 PyThreadState* __tstate = wxPyBeginAllowThreads();
43570 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43571 wxPyEndAllowThreads(__tstate);
43572 if (PyErr_Occurred()) SWIG_fail;
43573 }
43574 {
43575 resultobj = wxPyMake_wxObject(result, 0);
43576 }
43577 return resultobj;
43578 fail:
43579 return NULL;
43580 }
43581
43582
43583 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43584 PyObject *resultobj = 0;
43585 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43586 bool arg2 = (bool) true ;
43587 void *argp1 = 0 ;
43588 int res1 = 0 ;
43589 bool val2 ;
43590 int ecode2 = 0 ;
43591 PyObject * obj0 = 0 ;
43592 PyObject * obj1 = 0 ;
43593 char * kwnames[] = {
43594 (char *) "self",(char *) "enable", NULL
43595 };
43596
43597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43599 if (!SWIG_IsOK(res1)) {
43600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43601 }
43602 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43603 if (obj1) {
43604 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43605 if (!SWIG_IsOK(ecode2)) {
43606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43607 }
43608 arg2 = static_cast< bool >(val2);
43609 }
43610 {
43611 PyThreadState* __tstate = wxPyBeginAllowThreads();
43612 (arg1)->Enable(arg2);
43613 wxPyEndAllowThreads(__tstate);
43614 if (PyErr_Occurred()) SWIG_fail;
43615 }
43616 resultobj = SWIG_Py_Void();
43617 return resultobj;
43618 fail:
43619 return NULL;
43620 }
43621
43622
43623 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43624 PyObject *resultobj = 0;
43625 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43626 bool result;
43627 void *argp1 = 0 ;
43628 int res1 = 0 ;
43629 PyObject *swig_obj[1] ;
43630
43631 if (!args) SWIG_fail;
43632 swig_obj[0] = args;
43633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43634 if (!SWIG_IsOK(res1)) {
43635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43636 }
43637 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43638 {
43639 PyThreadState* __tstate = wxPyBeginAllowThreads();
43640 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43641 wxPyEndAllowThreads(__tstate);
43642 if (PyErr_Occurred()) SWIG_fail;
43643 }
43644 {
43645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43646 }
43647 return resultobj;
43648 fail:
43649 return NULL;
43650 }
43651
43652
43653 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43654 PyObject *resultobj = 0;
43655 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43656 bool arg2 = (bool) true ;
43657 void *argp1 = 0 ;
43658 int res1 = 0 ;
43659 bool val2 ;
43660 int ecode2 = 0 ;
43661 PyObject * obj0 = 0 ;
43662 PyObject * obj1 = 0 ;
43663 char * kwnames[] = {
43664 (char *) "self",(char *) "check", NULL
43665 };
43666
43667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43669 if (!SWIG_IsOK(res1)) {
43670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43671 }
43672 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43673 if (obj1) {
43674 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43675 if (!SWIG_IsOK(ecode2)) {
43676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43677 }
43678 arg2 = static_cast< bool >(val2);
43679 }
43680 {
43681 PyThreadState* __tstate = wxPyBeginAllowThreads();
43682 (arg1)->Check(arg2);
43683 wxPyEndAllowThreads(__tstate);
43684 if (PyErr_Occurred()) SWIG_fail;
43685 }
43686 resultobj = SWIG_Py_Void();
43687 return resultobj;
43688 fail:
43689 return NULL;
43690 }
43691
43692
43693 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43694 PyObject *resultobj = 0;
43695 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43696 bool result;
43697 void *argp1 = 0 ;
43698 int res1 = 0 ;
43699 PyObject *swig_obj[1] ;
43700
43701 if (!args) SWIG_fail;
43702 swig_obj[0] = args;
43703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43704 if (!SWIG_IsOK(res1)) {
43705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43706 }
43707 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43708 {
43709 PyThreadState* __tstate = wxPyBeginAllowThreads();
43710 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43711 wxPyEndAllowThreads(__tstate);
43712 if (PyErr_Occurred()) SWIG_fail;
43713 }
43714 {
43715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43716 }
43717 return resultobj;
43718 fail:
43719 return NULL;
43720 }
43721
43722
43723 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43724 PyObject *resultobj = 0;
43725 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43726 void *argp1 = 0 ;
43727 int res1 = 0 ;
43728 PyObject *swig_obj[1] ;
43729
43730 if (!args) SWIG_fail;
43731 swig_obj[0] = args;
43732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43733 if (!SWIG_IsOK(res1)) {
43734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43735 }
43736 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43737 {
43738 PyThreadState* __tstate = wxPyBeginAllowThreads();
43739 (arg1)->Toggle();
43740 wxPyEndAllowThreads(__tstate);
43741 if (PyErr_Occurred()) SWIG_fail;
43742 }
43743 resultobj = SWIG_Py_Void();
43744 return resultobj;
43745 fail:
43746 return NULL;
43747 }
43748
43749
43750 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43751 PyObject *resultobj = 0;
43752 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43753 wxString *arg2 = 0 ;
43754 void *argp1 = 0 ;
43755 int res1 = 0 ;
43756 bool temp2 = false ;
43757 PyObject * obj0 = 0 ;
43758 PyObject * obj1 = 0 ;
43759 char * kwnames[] = {
43760 (char *) "self",(char *) "str", NULL
43761 };
43762
43763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43765 if (!SWIG_IsOK(res1)) {
43766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43767 }
43768 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43769 {
43770 arg2 = wxString_in_helper(obj1);
43771 if (arg2 == NULL) SWIG_fail;
43772 temp2 = true;
43773 }
43774 {
43775 PyThreadState* __tstate = wxPyBeginAllowThreads();
43776 (arg1)->SetHelp((wxString const &)*arg2);
43777 wxPyEndAllowThreads(__tstate);
43778 if (PyErr_Occurred()) SWIG_fail;
43779 }
43780 resultobj = SWIG_Py_Void();
43781 {
43782 if (temp2)
43783 delete arg2;
43784 }
43785 return resultobj;
43786 fail:
43787 {
43788 if (temp2)
43789 delete arg2;
43790 }
43791 return NULL;
43792 }
43793
43794
43795 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43796 PyObject *resultobj = 0;
43797 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43798 wxString *result = 0 ;
43799 void *argp1 = 0 ;
43800 int res1 = 0 ;
43801 PyObject *swig_obj[1] ;
43802
43803 if (!args) SWIG_fail;
43804 swig_obj[0] = args;
43805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43806 if (!SWIG_IsOK(res1)) {
43807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43808 }
43809 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43810 {
43811 PyThreadState* __tstate = wxPyBeginAllowThreads();
43812 {
43813 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43814 result = (wxString *) &_result_ref;
43815 }
43816 wxPyEndAllowThreads(__tstate);
43817 if (PyErr_Occurred()) SWIG_fail;
43818 }
43819 {
43820 #if wxUSE_UNICODE
43821 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43822 #else
43823 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43824 #endif
43825 }
43826 return resultobj;
43827 fail:
43828 return NULL;
43829 }
43830
43831
43832 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43833 PyObject *resultobj = 0;
43834 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43835 wxAcceleratorEntry *result = 0 ;
43836 void *argp1 = 0 ;
43837 int res1 = 0 ;
43838 PyObject *swig_obj[1] ;
43839
43840 if (!args) SWIG_fail;
43841 swig_obj[0] = args;
43842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43843 if (!SWIG_IsOK(res1)) {
43844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43845 }
43846 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43847 {
43848 PyThreadState* __tstate = wxPyBeginAllowThreads();
43849 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43850 wxPyEndAllowThreads(__tstate);
43851 if (PyErr_Occurred()) SWIG_fail;
43852 }
43853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43854 return resultobj;
43855 fail:
43856 return NULL;
43857 }
43858
43859
43860 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43861 PyObject *resultobj = 0;
43862 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43863 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43864 void *argp1 = 0 ;
43865 int res1 = 0 ;
43866 void *argp2 = 0 ;
43867 int res2 = 0 ;
43868 PyObject * obj0 = 0 ;
43869 PyObject * obj1 = 0 ;
43870 char * kwnames[] = {
43871 (char *) "self",(char *) "accel", NULL
43872 };
43873
43874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43876 if (!SWIG_IsOK(res1)) {
43877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43878 }
43879 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43880 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43881 if (!SWIG_IsOK(res2)) {
43882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43883 }
43884 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43885 {
43886 PyThreadState* __tstate = wxPyBeginAllowThreads();
43887 (arg1)->SetAccel(arg2);
43888 wxPyEndAllowThreads(__tstate);
43889 if (PyErr_Occurred()) SWIG_fail;
43890 }
43891 resultobj = SWIG_Py_Void();
43892 return resultobj;
43893 fail:
43894 return NULL;
43895 }
43896
43897
43898 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43899 PyObject *resultobj = 0;
43900 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43901 wxBitmap *arg2 = 0 ;
43902 void *argp1 = 0 ;
43903 int res1 = 0 ;
43904 void *argp2 = 0 ;
43905 int res2 = 0 ;
43906 PyObject * obj0 = 0 ;
43907 PyObject * obj1 = 0 ;
43908 char * kwnames[] = {
43909 (char *) "self",(char *) "bitmap", NULL
43910 };
43911
43912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43914 if (!SWIG_IsOK(res1)) {
43915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43916 }
43917 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43918 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43919 if (!SWIG_IsOK(res2)) {
43920 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43921 }
43922 if (!argp2) {
43923 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43924 }
43925 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43926 {
43927 PyThreadState* __tstate = wxPyBeginAllowThreads();
43928 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43929 wxPyEndAllowThreads(__tstate);
43930 if (PyErr_Occurred()) SWIG_fail;
43931 }
43932 resultobj = SWIG_Py_Void();
43933 return resultobj;
43934 fail:
43935 return NULL;
43936 }
43937
43938
43939 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43940 PyObject *resultobj = 0;
43941 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43942 wxBitmap *result = 0 ;
43943 void *argp1 = 0 ;
43944 int res1 = 0 ;
43945 PyObject *swig_obj[1] ;
43946
43947 if (!args) SWIG_fail;
43948 swig_obj[0] = args;
43949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43950 if (!SWIG_IsOK(res1)) {
43951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43952 }
43953 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43954 {
43955 PyThreadState* __tstate = wxPyBeginAllowThreads();
43956 {
43957 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43958 result = (wxBitmap *) &_result_ref;
43959 }
43960 wxPyEndAllowThreads(__tstate);
43961 if (PyErr_Occurred()) SWIG_fail;
43962 }
43963 {
43964 wxBitmap* resultptr = new wxBitmap(*result);
43965 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43966 }
43967 return resultobj;
43968 fail:
43969 return NULL;
43970 }
43971
43972
43973 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43974 PyObject *resultobj = 0;
43975 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43976 wxFont *arg2 = 0 ;
43977 void *argp1 = 0 ;
43978 int res1 = 0 ;
43979 void *argp2 = 0 ;
43980 int res2 = 0 ;
43981 PyObject * obj0 = 0 ;
43982 PyObject * obj1 = 0 ;
43983 char * kwnames[] = {
43984 (char *) "self",(char *) "font", NULL
43985 };
43986
43987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43989 if (!SWIG_IsOK(res1)) {
43990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43991 }
43992 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43993 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43994 if (!SWIG_IsOK(res2)) {
43995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43996 }
43997 if (!argp2) {
43998 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43999 }
44000 arg2 = reinterpret_cast< wxFont * >(argp2);
44001 {
44002 PyThreadState* __tstate = wxPyBeginAllowThreads();
44003 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
44004 wxPyEndAllowThreads(__tstate);
44005 if (PyErr_Occurred()) SWIG_fail;
44006 }
44007 resultobj = SWIG_Py_Void();
44008 return resultobj;
44009 fail:
44010 return NULL;
44011 }
44012
44013
44014 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44015 PyObject *resultobj = 0;
44016 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44017 wxFont result;
44018 void *argp1 = 0 ;
44019 int res1 = 0 ;
44020 PyObject *swig_obj[1] ;
44021
44022 if (!args) SWIG_fail;
44023 swig_obj[0] = args;
44024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44025 if (!SWIG_IsOK(res1)) {
44026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44027 }
44028 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44029 {
44030 PyThreadState* __tstate = wxPyBeginAllowThreads();
44031 result = wxMenuItem_GetFont(arg1);
44032 wxPyEndAllowThreads(__tstate);
44033 if (PyErr_Occurred()) SWIG_fail;
44034 }
44035 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44036 return resultobj;
44037 fail:
44038 return NULL;
44039 }
44040
44041
44042 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44043 PyObject *resultobj = 0;
44044 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44045 wxColour *arg2 = 0 ;
44046 void *argp1 = 0 ;
44047 int res1 = 0 ;
44048 wxColour temp2 ;
44049 PyObject * obj0 = 0 ;
44050 PyObject * obj1 = 0 ;
44051 char * kwnames[] = {
44052 (char *) "self",(char *) "colText", NULL
44053 };
44054
44055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44057 if (!SWIG_IsOK(res1)) {
44058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44059 }
44060 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44061 {
44062 arg2 = &temp2;
44063 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44064 }
44065 {
44066 PyThreadState* __tstate = wxPyBeginAllowThreads();
44067 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
44068 wxPyEndAllowThreads(__tstate);
44069 if (PyErr_Occurred()) SWIG_fail;
44070 }
44071 resultobj = SWIG_Py_Void();
44072 return resultobj;
44073 fail:
44074 return NULL;
44075 }
44076
44077
44078 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44079 PyObject *resultobj = 0;
44080 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44081 wxColour result;
44082 void *argp1 = 0 ;
44083 int res1 = 0 ;
44084 PyObject *swig_obj[1] ;
44085
44086 if (!args) SWIG_fail;
44087 swig_obj[0] = args;
44088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44089 if (!SWIG_IsOK(res1)) {
44090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44091 }
44092 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44093 {
44094 PyThreadState* __tstate = wxPyBeginAllowThreads();
44095 result = wxMenuItem_GetTextColour(arg1);
44096 wxPyEndAllowThreads(__tstate);
44097 if (PyErr_Occurred()) SWIG_fail;
44098 }
44099 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44100 return resultobj;
44101 fail:
44102 return NULL;
44103 }
44104
44105
44106 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44107 PyObject *resultobj = 0;
44108 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44109 wxColour *arg2 = 0 ;
44110 void *argp1 = 0 ;
44111 int res1 = 0 ;
44112 wxColour temp2 ;
44113 PyObject * obj0 = 0 ;
44114 PyObject * obj1 = 0 ;
44115 char * kwnames[] = {
44116 (char *) "self",(char *) "colBack", NULL
44117 };
44118
44119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44121 if (!SWIG_IsOK(res1)) {
44122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44123 }
44124 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44125 {
44126 arg2 = &temp2;
44127 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44128 }
44129 {
44130 PyThreadState* __tstate = wxPyBeginAllowThreads();
44131 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
44132 wxPyEndAllowThreads(__tstate);
44133 if (PyErr_Occurred()) SWIG_fail;
44134 }
44135 resultobj = SWIG_Py_Void();
44136 return resultobj;
44137 fail:
44138 return NULL;
44139 }
44140
44141
44142 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44143 PyObject *resultobj = 0;
44144 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44145 wxColour result;
44146 void *argp1 = 0 ;
44147 int res1 = 0 ;
44148 PyObject *swig_obj[1] ;
44149
44150 if (!args) SWIG_fail;
44151 swig_obj[0] = args;
44152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44153 if (!SWIG_IsOK(res1)) {
44154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44155 }
44156 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44157 {
44158 PyThreadState* __tstate = wxPyBeginAllowThreads();
44159 result = wxMenuItem_GetBackgroundColour(arg1);
44160 wxPyEndAllowThreads(__tstate);
44161 if (PyErr_Occurred()) SWIG_fail;
44162 }
44163 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44164 return resultobj;
44165 fail:
44166 return NULL;
44167 }
44168
44169
44170 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44171 PyObject *resultobj = 0;
44172 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44173 wxBitmap *arg2 = 0 ;
44174 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44175 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44176 void *argp1 = 0 ;
44177 int res1 = 0 ;
44178 void *argp2 = 0 ;
44179 int res2 = 0 ;
44180 void *argp3 = 0 ;
44181 int res3 = 0 ;
44182 PyObject * obj0 = 0 ;
44183 PyObject * obj1 = 0 ;
44184 PyObject * obj2 = 0 ;
44185 char * kwnames[] = {
44186 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44187 };
44188
44189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44191 if (!SWIG_IsOK(res1)) {
44192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44193 }
44194 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44195 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44196 if (!SWIG_IsOK(res2)) {
44197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44198 }
44199 if (!argp2) {
44200 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44201 }
44202 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44203 if (obj2) {
44204 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44205 if (!SWIG_IsOK(res3)) {
44206 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44207 }
44208 if (!argp3) {
44209 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44210 }
44211 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44212 }
44213 {
44214 PyThreadState* __tstate = wxPyBeginAllowThreads();
44215 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44216 wxPyEndAllowThreads(__tstate);
44217 if (PyErr_Occurred()) SWIG_fail;
44218 }
44219 resultobj = SWIG_Py_Void();
44220 return resultobj;
44221 fail:
44222 return NULL;
44223 }
44224
44225
44226 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44227 PyObject *resultobj = 0;
44228 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44229 wxBitmap *arg2 = 0 ;
44230 void *argp1 = 0 ;
44231 int res1 = 0 ;
44232 void *argp2 = 0 ;
44233 int res2 = 0 ;
44234 PyObject * obj0 = 0 ;
44235 PyObject * obj1 = 0 ;
44236 char * kwnames[] = {
44237 (char *) "self",(char *) "bmpDisabled", NULL
44238 };
44239
44240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44242 if (!SWIG_IsOK(res1)) {
44243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44244 }
44245 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44246 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44247 if (!SWIG_IsOK(res2)) {
44248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44249 }
44250 if (!argp2) {
44251 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44252 }
44253 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44254 {
44255 PyThreadState* __tstate = wxPyBeginAllowThreads();
44256 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
44257 wxPyEndAllowThreads(__tstate);
44258 if (PyErr_Occurred()) SWIG_fail;
44259 }
44260 resultobj = SWIG_Py_Void();
44261 return resultobj;
44262 fail:
44263 return NULL;
44264 }
44265
44266
44267 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44268 PyObject *resultobj = 0;
44269 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44270 wxBitmap *result = 0 ;
44271 void *argp1 = 0 ;
44272 int res1 = 0 ;
44273 PyObject *swig_obj[1] ;
44274
44275 if (!args) SWIG_fail;
44276 swig_obj[0] = args;
44277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44278 if (!SWIG_IsOK(res1)) {
44279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44280 }
44281 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44282 {
44283 PyThreadState* __tstate = wxPyBeginAllowThreads();
44284 {
44285 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
44286 result = (wxBitmap *) &_result_ref;
44287 }
44288 wxPyEndAllowThreads(__tstate);
44289 if (PyErr_Occurred()) SWIG_fail;
44290 }
44291 {
44292 wxBitmap* resultptr = new wxBitmap(*result);
44293 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44294 }
44295 return resultobj;
44296 fail:
44297 return NULL;
44298 }
44299
44300
44301 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44302 PyObject *resultobj = 0;
44303 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44304 int arg2 ;
44305 void *argp1 = 0 ;
44306 int res1 = 0 ;
44307 int val2 ;
44308 int ecode2 = 0 ;
44309 PyObject * obj0 = 0 ;
44310 PyObject * obj1 = 0 ;
44311 char * kwnames[] = {
44312 (char *) "self",(char *) "nWidth", NULL
44313 };
44314
44315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44317 if (!SWIG_IsOK(res1)) {
44318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44319 }
44320 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44321 ecode2 = SWIG_AsVal_int(obj1, &val2);
44322 if (!SWIG_IsOK(ecode2)) {
44323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44324 }
44325 arg2 = static_cast< int >(val2);
44326 {
44327 PyThreadState* __tstate = wxPyBeginAllowThreads();
44328 wxMenuItem_SetMarginWidth(arg1,arg2);
44329 wxPyEndAllowThreads(__tstate);
44330 if (PyErr_Occurred()) SWIG_fail;
44331 }
44332 resultobj = SWIG_Py_Void();
44333 return resultobj;
44334 fail:
44335 return NULL;
44336 }
44337
44338
44339 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44340 PyObject *resultobj = 0;
44341 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44342 int result;
44343 void *argp1 = 0 ;
44344 int res1 = 0 ;
44345 PyObject *swig_obj[1] ;
44346
44347 if (!args) SWIG_fail;
44348 swig_obj[0] = args;
44349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44350 if (!SWIG_IsOK(res1)) {
44351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44352 }
44353 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44354 {
44355 PyThreadState* __tstate = wxPyBeginAllowThreads();
44356 result = (int)wxMenuItem_GetMarginWidth(arg1);
44357 wxPyEndAllowThreads(__tstate);
44358 if (PyErr_Occurred()) SWIG_fail;
44359 }
44360 resultobj = SWIG_From_int(static_cast< int >(result));
44361 return resultobj;
44362 fail:
44363 return NULL;
44364 }
44365
44366
44367 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44368 PyObject *resultobj = 0;
44369 int result;
44370
44371 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44372 {
44373 PyThreadState* __tstate = wxPyBeginAllowThreads();
44374 result = (int)wxMenuItem_GetDefaultMarginWidth();
44375 wxPyEndAllowThreads(__tstate);
44376 if (PyErr_Occurred()) SWIG_fail;
44377 }
44378 resultobj = SWIG_From_int(static_cast< int >(result));
44379 return resultobj;
44380 fail:
44381 return NULL;
44382 }
44383
44384
44385 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44386 PyObject *resultobj = 0;
44387 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44388 bool result;
44389 void *argp1 = 0 ;
44390 int res1 = 0 ;
44391 PyObject *swig_obj[1] ;
44392
44393 if (!args) SWIG_fail;
44394 swig_obj[0] = args;
44395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44396 if (!SWIG_IsOK(res1)) {
44397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44398 }
44399 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44400 {
44401 PyThreadState* __tstate = wxPyBeginAllowThreads();
44402 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
44403 wxPyEndAllowThreads(__tstate);
44404 if (PyErr_Occurred()) SWIG_fail;
44405 }
44406 {
44407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44408 }
44409 return resultobj;
44410 fail:
44411 return NULL;
44412 }
44413
44414
44415 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44416 PyObject *resultobj = 0;
44417 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44418 bool arg2 = (bool) true ;
44419 void *argp1 = 0 ;
44420 int res1 = 0 ;
44421 bool val2 ;
44422 int ecode2 = 0 ;
44423 PyObject * obj0 = 0 ;
44424 PyObject * obj1 = 0 ;
44425 char * kwnames[] = {
44426 (char *) "self",(char *) "ownerDrawn", NULL
44427 };
44428
44429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44431 if (!SWIG_IsOK(res1)) {
44432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44433 }
44434 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44435 if (obj1) {
44436 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44437 if (!SWIG_IsOK(ecode2)) {
44438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44439 }
44440 arg2 = static_cast< bool >(val2);
44441 }
44442 {
44443 PyThreadState* __tstate = wxPyBeginAllowThreads();
44444 wxMenuItem_SetOwnerDrawn(arg1,arg2);
44445 wxPyEndAllowThreads(__tstate);
44446 if (PyErr_Occurred()) SWIG_fail;
44447 }
44448 resultobj = SWIG_Py_Void();
44449 return resultobj;
44450 fail:
44451 return NULL;
44452 }
44453
44454
44455 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44456 PyObject *resultobj = 0;
44457 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44458 void *argp1 = 0 ;
44459 int res1 = 0 ;
44460 PyObject *swig_obj[1] ;
44461
44462 if (!args) SWIG_fail;
44463 swig_obj[0] = args;
44464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44465 if (!SWIG_IsOK(res1)) {
44466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44467 }
44468 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44469 {
44470 PyThreadState* __tstate = wxPyBeginAllowThreads();
44471 wxMenuItem_ResetOwnerDrawn(arg1);
44472 wxPyEndAllowThreads(__tstate);
44473 if (PyErr_Occurred()) SWIG_fail;
44474 }
44475 resultobj = SWIG_Py_Void();
44476 return resultobj;
44477 fail:
44478 return NULL;
44479 }
44480
44481
44482 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44483 PyObject *obj;
44484 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44485 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44486 return SWIG_Py_Void();
44487 }
44488
44489 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44490 return SWIG_Python_InitShadowInstance(args);
44491 }
44492
44493 SWIGINTERN int ControlNameStr_set(PyObject *) {
44494 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44495 return 1;
44496 }
44497
44498
44499 SWIGINTERN PyObject *ControlNameStr_get(void) {
44500 PyObject *pyobj = 0;
44501
44502 {
44503 #if wxUSE_UNICODE
44504 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44505 #else
44506 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44507 #endif
44508 }
44509 return pyobj;
44510 }
44511
44512
44513 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44514 PyObject *resultobj = 0;
44515 wxWindow *arg1 = (wxWindow *) 0 ;
44516 int arg2 = (int) -1 ;
44517 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44518 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44519 wxSize const &arg4_defvalue = wxDefaultSize ;
44520 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44521 long arg5 = (long) 0 ;
44522 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44523 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44524 wxString const &arg7_defvalue = wxPyControlNameStr ;
44525 wxString *arg7 = (wxString *) &arg7_defvalue ;
44526 wxControl *result = 0 ;
44527 void *argp1 = 0 ;
44528 int res1 = 0 ;
44529 int val2 ;
44530 int ecode2 = 0 ;
44531 wxPoint temp3 ;
44532 wxSize temp4 ;
44533 long val5 ;
44534 int ecode5 = 0 ;
44535 void *argp6 = 0 ;
44536 int res6 = 0 ;
44537 bool temp7 = false ;
44538 PyObject * obj0 = 0 ;
44539 PyObject * obj1 = 0 ;
44540 PyObject * obj2 = 0 ;
44541 PyObject * obj3 = 0 ;
44542 PyObject * obj4 = 0 ;
44543 PyObject * obj5 = 0 ;
44544 PyObject * obj6 = 0 ;
44545 char * kwnames[] = {
44546 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44547 };
44548
44549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44551 if (!SWIG_IsOK(res1)) {
44552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44553 }
44554 arg1 = reinterpret_cast< wxWindow * >(argp1);
44555 if (obj1) {
44556 ecode2 = SWIG_AsVal_int(obj1, &val2);
44557 if (!SWIG_IsOK(ecode2)) {
44558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44559 }
44560 arg2 = static_cast< int >(val2);
44561 }
44562 if (obj2) {
44563 {
44564 arg3 = &temp3;
44565 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44566 }
44567 }
44568 if (obj3) {
44569 {
44570 arg4 = &temp4;
44571 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44572 }
44573 }
44574 if (obj4) {
44575 ecode5 = SWIG_AsVal_long(obj4, &val5);
44576 if (!SWIG_IsOK(ecode5)) {
44577 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44578 }
44579 arg5 = static_cast< long >(val5);
44580 }
44581 if (obj5) {
44582 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44583 if (!SWIG_IsOK(res6)) {
44584 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44585 }
44586 if (!argp6) {
44587 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44588 }
44589 arg6 = reinterpret_cast< wxValidator * >(argp6);
44590 }
44591 if (obj6) {
44592 {
44593 arg7 = wxString_in_helper(obj6);
44594 if (arg7 == NULL) SWIG_fail;
44595 temp7 = true;
44596 }
44597 }
44598 {
44599 if (!wxPyCheckForApp()) SWIG_fail;
44600 PyThreadState* __tstate = wxPyBeginAllowThreads();
44601 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44602 wxPyEndAllowThreads(__tstate);
44603 if (PyErr_Occurred()) SWIG_fail;
44604 }
44605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44606 {
44607 if (temp7)
44608 delete arg7;
44609 }
44610 return resultobj;
44611 fail:
44612 {
44613 if (temp7)
44614 delete arg7;
44615 }
44616 return NULL;
44617 }
44618
44619
44620 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44621 PyObject *resultobj = 0;
44622 wxControl *result = 0 ;
44623
44624 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44625 {
44626 if (!wxPyCheckForApp()) SWIG_fail;
44627 PyThreadState* __tstate = wxPyBeginAllowThreads();
44628 result = (wxControl *)new wxControl();
44629 wxPyEndAllowThreads(__tstate);
44630 if (PyErr_Occurred()) SWIG_fail;
44631 }
44632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44633 return resultobj;
44634 fail:
44635 return NULL;
44636 }
44637
44638
44639 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44640 PyObject *resultobj = 0;
44641 wxControl *arg1 = (wxControl *) 0 ;
44642 wxWindow *arg2 = (wxWindow *) 0 ;
44643 int arg3 = (int) -1 ;
44644 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44645 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44646 wxSize const &arg5_defvalue = wxDefaultSize ;
44647 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44648 long arg6 = (long) 0 ;
44649 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44650 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44651 wxString const &arg8_defvalue = wxPyControlNameStr ;
44652 wxString *arg8 = (wxString *) &arg8_defvalue ;
44653 bool result;
44654 void *argp1 = 0 ;
44655 int res1 = 0 ;
44656 void *argp2 = 0 ;
44657 int res2 = 0 ;
44658 int val3 ;
44659 int ecode3 = 0 ;
44660 wxPoint temp4 ;
44661 wxSize temp5 ;
44662 long val6 ;
44663 int ecode6 = 0 ;
44664 void *argp7 = 0 ;
44665 int res7 = 0 ;
44666 bool temp8 = false ;
44667 PyObject * obj0 = 0 ;
44668 PyObject * obj1 = 0 ;
44669 PyObject * obj2 = 0 ;
44670 PyObject * obj3 = 0 ;
44671 PyObject * obj4 = 0 ;
44672 PyObject * obj5 = 0 ;
44673 PyObject * obj6 = 0 ;
44674 PyObject * obj7 = 0 ;
44675 char * kwnames[] = {
44676 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44677 };
44678
44679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44681 if (!SWIG_IsOK(res1)) {
44682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44683 }
44684 arg1 = reinterpret_cast< wxControl * >(argp1);
44685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44686 if (!SWIG_IsOK(res2)) {
44687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44688 }
44689 arg2 = reinterpret_cast< wxWindow * >(argp2);
44690 if (obj2) {
44691 ecode3 = SWIG_AsVal_int(obj2, &val3);
44692 if (!SWIG_IsOK(ecode3)) {
44693 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44694 }
44695 arg3 = static_cast< int >(val3);
44696 }
44697 if (obj3) {
44698 {
44699 arg4 = &temp4;
44700 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44701 }
44702 }
44703 if (obj4) {
44704 {
44705 arg5 = &temp5;
44706 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44707 }
44708 }
44709 if (obj5) {
44710 ecode6 = SWIG_AsVal_long(obj5, &val6);
44711 if (!SWIG_IsOK(ecode6)) {
44712 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44713 }
44714 arg6 = static_cast< long >(val6);
44715 }
44716 if (obj6) {
44717 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44718 if (!SWIG_IsOK(res7)) {
44719 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44720 }
44721 if (!argp7) {
44722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44723 }
44724 arg7 = reinterpret_cast< wxValidator * >(argp7);
44725 }
44726 if (obj7) {
44727 {
44728 arg8 = wxString_in_helper(obj7);
44729 if (arg8 == NULL) SWIG_fail;
44730 temp8 = true;
44731 }
44732 }
44733 {
44734 PyThreadState* __tstate = wxPyBeginAllowThreads();
44735 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44736 wxPyEndAllowThreads(__tstate);
44737 if (PyErr_Occurred()) SWIG_fail;
44738 }
44739 {
44740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44741 }
44742 {
44743 if (temp8)
44744 delete arg8;
44745 }
44746 return resultobj;
44747 fail:
44748 {
44749 if (temp8)
44750 delete arg8;
44751 }
44752 return NULL;
44753 }
44754
44755
44756 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44757 PyObject *resultobj = 0;
44758 wxControl *arg1 = (wxControl *) 0 ;
44759 int result;
44760 void *argp1 = 0 ;
44761 int res1 = 0 ;
44762 PyObject *swig_obj[1] ;
44763
44764 if (!args) SWIG_fail;
44765 swig_obj[0] = args;
44766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44767 if (!SWIG_IsOK(res1)) {
44768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44769 }
44770 arg1 = reinterpret_cast< wxControl * >(argp1);
44771 {
44772 PyThreadState* __tstate = wxPyBeginAllowThreads();
44773 result = (int)((wxControl const *)arg1)->GetAlignment();
44774 wxPyEndAllowThreads(__tstate);
44775 if (PyErr_Occurred()) SWIG_fail;
44776 }
44777 resultobj = SWIG_From_int(static_cast< int >(result));
44778 return resultobj;
44779 fail:
44780 return NULL;
44781 }
44782
44783
44784 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44785 PyObject *resultobj = 0;
44786 wxControl *arg1 = (wxControl *) 0 ;
44787 wxString result;
44788 void *argp1 = 0 ;
44789 int res1 = 0 ;
44790 PyObject *swig_obj[1] ;
44791
44792 if (!args) SWIG_fail;
44793 swig_obj[0] = args;
44794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44795 if (!SWIG_IsOK(res1)) {
44796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44797 }
44798 arg1 = reinterpret_cast< wxControl * >(argp1);
44799 {
44800 PyThreadState* __tstate = wxPyBeginAllowThreads();
44801 result = ((wxControl const *)arg1)->GetLabelText();
44802 wxPyEndAllowThreads(__tstate);
44803 if (PyErr_Occurred()) SWIG_fail;
44804 }
44805 {
44806 #if wxUSE_UNICODE
44807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44808 #else
44809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44810 #endif
44811 }
44812 return resultobj;
44813 fail:
44814 return NULL;
44815 }
44816
44817
44818 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44819 PyObject *resultobj = 0;
44820 wxControl *arg1 = (wxControl *) 0 ;
44821 wxCommandEvent *arg2 = 0 ;
44822 void *argp1 = 0 ;
44823 int res1 = 0 ;
44824 void *argp2 = 0 ;
44825 int res2 = 0 ;
44826 PyObject * obj0 = 0 ;
44827 PyObject * obj1 = 0 ;
44828 char * kwnames[] = {
44829 (char *) "self",(char *) "event", NULL
44830 };
44831
44832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44834 if (!SWIG_IsOK(res1)) {
44835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44836 }
44837 arg1 = reinterpret_cast< wxControl * >(argp1);
44838 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44839 if (!SWIG_IsOK(res2)) {
44840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44841 }
44842 if (!argp2) {
44843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44844 }
44845 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44846 {
44847 PyThreadState* __tstate = wxPyBeginAllowThreads();
44848 (arg1)->Command(*arg2);
44849 wxPyEndAllowThreads(__tstate);
44850 if (PyErr_Occurred()) SWIG_fail;
44851 }
44852 resultobj = SWIG_Py_Void();
44853 return resultobj;
44854 fail:
44855 return NULL;
44856 }
44857
44858
44859 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44860 PyObject *resultobj = 0;
44861 wxControl *arg1 = (wxControl *) 0 ;
44862 wxString result;
44863 void *argp1 = 0 ;
44864 int res1 = 0 ;
44865 PyObject *swig_obj[1] ;
44866
44867 if (!args) SWIG_fail;
44868 swig_obj[0] = args;
44869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44870 if (!SWIG_IsOK(res1)) {
44871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44872 }
44873 arg1 = reinterpret_cast< wxControl * >(argp1);
44874 {
44875 PyThreadState* __tstate = wxPyBeginAllowThreads();
44876 result = (arg1)->GetLabel();
44877 wxPyEndAllowThreads(__tstate);
44878 if (PyErr_Occurred()) SWIG_fail;
44879 }
44880 {
44881 #if wxUSE_UNICODE
44882 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44883 #else
44884 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44885 #endif
44886 }
44887 return resultobj;
44888 fail:
44889 return NULL;
44890 }
44891
44892
44893 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44894 PyObject *resultobj = 0;
44895 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44896 SwigValueWrapper<wxVisualAttributes > result;
44897 int val1 ;
44898 int ecode1 = 0 ;
44899 PyObject * obj0 = 0 ;
44900 char * kwnames[] = {
44901 (char *) "variant", NULL
44902 };
44903
44904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44905 if (obj0) {
44906 ecode1 = SWIG_AsVal_int(obj0, &val1);
44907 if (!SWIG_IsOK(ecode1)) {
44908 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44909 }
44910 arg1 = static_cast< wxWindowVariant >(val1);
44911 }
44912 {
44913 if (!wxPyCheckForApp()) SWIG_fail;
44914 PyThreadState* __tstate = wxPyBeginAllowThreads();
44915 result = wxControl::GetClassDefaultAttributes(arg1);
44916 wxPyEndAllowThreads(__tstate);
44917 if (PyErr_Occurred()) SWIG_fail;
44918 }
44919 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44920 return resultobj;
44921 fail:
44922 return NULL;
44923 }
44924
44925
44926 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44927 PyObject *obj;
44928 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44929 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44930 return SWIG_Py_Void();
44931 }
44932
44933 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44934 return SWIG_Python_InitShadowInstance(args);
44935 }
44936
44937 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44938 PyObject *resultobj = 0;
44939 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44940 wxString *arg2 = 0 ;
44941 PyObject *arg3 = (PyObject *) NULL ;
44942 int result;
44943 void *argp1 = 0 ;
44944 int res1 = 0 ;
44945 bool temp2 = false ;
44946 PyObject * obj0 = 0 ;
44947 PyObject * obj1 = 0 ;
44948 PyObject * obj2 = 0 ;
44949 char * kwnames[] = {
44950 (char *) "self",(char *) "item",(char *) "clientData", NULL
44951 };
44952
44953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44955 if (!SWIG_IsOK(res1)) {
44956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44957 }
44958 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44959 {
44960 arg2 = wxString_in_helper(obj1);
44961 if (arg2 == NULL) SWIG_fail;
44962 temp2 = true;
44963 }
44964 if (obj2) {
44965 arg3 = obj2;
44966 }
44967 {
44968 PyThreadState* __tstate = wxPyBeginAllowThreads();
44969 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44970 wxPyEndAllowThreads(__tstate);
44971 if (PyErr_Occurred()) SWIG_fail;
44972 }
44973 resultobj = SWIG_From_int(static_cast< int >(result));
44974 {
44975 if (temp2)
44976 delete arg2;
44977 }
44978 return resultobj;
44979 fail:
44980 {
44981 if (temp2)
44982 delete arg2;
44983 }
44984 return NULL;
44985 }
44986
44987
44988 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44989 PyObject *resultobj = 0;
44990 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44991 wxArrayString *arg2 = 0 ;
44992 void *argp1 = 0 ;
44993 int res1 = 0 ;
44994 bool temp2 = false ;
44995 PyObject * obj0 = 0 ;
44996 PyObject * obj1 = 0 ;
44997 char * kwnames[] = {
44998 (char *) "self",(char *) "strings", NULL
44999 };
45000
45001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45003 if (!SWIG_IsOK(res1)) {
45004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45005 }
45006 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45007 {
45008 if (! PySequence_Check(obj1)) {
45009 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45010 SWIG_fail;
45011 }
45012 arg2 = new wxArrayString;
45013 temp2 = true;
45014 int i, len=PySequence_Length(obj1);
45015 for (i=0; i<len; i++) {
45016 PyObject* item = PySequence_GetItem(obj1, i);
45017 wxString* s = wxString_in_helper(item);
45018 if (PyErr_Occurred()) SWIG_fail;
45019 arg2->Add(*s);
45020 delete s;
45021 Py_DECREF(item);
45022 }
45023 }
45024 {
45025 PyThreadState* __tstate = wxPyBeginAllowThreads();
45026 (arg1)->Append((wxArrayString const &)*arg2);
45027 wxPyEndAllowThreads(__tstate);
45028 if (PyErr_Occurred()) SWIG_fail;
45029 }
45030 resultobj = SWIG_Py_Void();
45031 {
45032 if (temp2) delete arg2;
45033 }
45034 return resultobj;
45035 fail:
45036 {
45037 if (temp2) delete arg2;
45038 }
45039 return NULL;
45040 }
45041
45042
45043 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45044 PyObject *resultobj = 0;
45045 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45046 wxString *arg2 = 0 ;
45047 unsigned int arg3 ;
45048 PyObject *arg4 = (PyObject *) NULL ;
45049 int result;
45050 void *argp1 = 0 ;
45051 int res1 = 0 ;
45052 bool temp2 = false ;
45053 unsigned int val3 ;
45054 int ecode3 = 0 ;
45055 PyObject * obj0 = 0 ;
45056 PyObject * obj1 = 0 ;
45057 PyObject * obj2 = 0 ;
45058 PyObject * obj3 = 0 ;
45059 char * kwnames[] = {
45060 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45061 };
45062
45063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45065 if (!SWIG_IsOK(res1)) {
45066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45067 }
45068 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45069 {
45070 arg2 = wxString_in_helper(obj1);
45071 if (arg2 == NULL) SWIG_fail;
45072 temp2 = true;
45073 }
45074 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45075 if (!SWIG_IsOK(ecode3)) {
45076 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45077 }
45078 arg3 = static_cast< unsigned int >(val3);
45079 if (obj3) {
45080 arg4 = obj3;
45081 }
45082 {
45083 PyThreadState* __tstate = wxPyBeginAllowThreads();
45084 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45085 wxPyEndAllowThreads(__tstate);
45086 if (PyErr_Occurred()) SWIG_fail;
45087 }
45088 resultobj = SWIG_From_int(static_cast< int >(result));
45089 {
45090 if (temp2)
45091 delete arg2;
45092 }
45093 return resultobj;
45094 fail:
45095 {
45096 if (temp2)
45097 delete arg2;
45098 }
45099 return NULL;
45100 }
45101
45102
45103 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45104 PyObject *resultobj = 0;
45105 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45106 void *argp1 = 0 ;
45107 int res1 = 0 ;
45108 PyObject *swig_obj[1] ;
45109
45110 if (!args) SWIG_fail;
45111 swig_obj[0] = args;
45112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45113 if (!SWIG_IsOK(res1)) {
45114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45115 }
45116 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45117 {
45118 PyThreadState* __tstate = wxPyBeginAllowThreads();
45119 (arg1)->Clear();
45120 wxPyEndAllowThreads(__tstate);
45121 if (PyErr_Occurred()) SWIG_fail;
45122 }
45123 resultobj = SWIG_Py_Void();
45124 return resultobj;
45125 fail:
45126 return NULL;
45127 }
45128
45129
45130 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45131 PyObject *resultobj = 0;
45132 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45133 unsigned int arg2 ;
45134 void *argp1 = 0 ;
45135 int res1 = 0 ;
45136 unsigned int val2 ;
45137 int ecode2 = 0 ;
45138 PyObject * obj0 = 0 ;
45139 PyObject * obj1 = 0 ;
45140 char * kwnames[] = {
45141 (char *) "self",(char *) "n", NULL
45142 };
45143
45144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45146 if (!SWIG_IsOK(res1)) {
45147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45148 }
45149 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45150 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45151 if (!SWIG_IsOK(ecode2)) {
45152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45153 }
45154 arg2 = static_cast< unsigned int >(val2);
45155 {
45156 PyThreadState* __tstate = wxPyBeginAllowThreads();
45157 (arg1)->Delete(arg2);
45158 wxPyEndAllowThreads(__tstate);
45159 if (PyErr_Occurred()) SWIG_fail;
45160 }
45161 resultobj = SWIG_Py_Void();
45162 return resultobj;
45163 fail:
45164 return NULL;
45165 }
45166
45167
45168 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45169 PyObject *resultobj = 0;
45170 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45171 unsigned int arg2 ;
45172 PyObject *result = 0 ;
45173 void *argp1 = 0 ;
45174 int res1 = 0 ;
45175 unsigned int val2 ;
45176 int ecode2 = 0 ;
45177 PyObject * obj0 = 0 ;
45178 PyObject * obj1 = 0 ;
45179 char * kwnames[] = {
45180 (char *) "self",(char *) "n", NULL
45181 };
45182
45183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45185 if (!SWIG_IsOK(res1)) {
45186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45187 }
45188 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45189 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45190 if (!SWIG_IsOK(ecode2)) {
45191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45192 }
45193 arg2 = static_cast< unsigned int >(val2);
45194 {
45195 PyThreadState* __tstate = wxPyBeginAllowThreads();
45196 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45197 wxPyEndAllowThreads(__tstate);
45198 if (PyErr_Occurred()) SWIG_fail;
45199 }
45200 resultobj = result;
45201 return resultobj;
45202 fail:
45203 return NULL;
45204 }
45205
45206
45207 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45208 PyObject *resultobj = 0;
45209 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45210 unsigned int arg2 ;
45211 PyObject *arg3 = (PyObject *) 0 ;
45212 void *argp1 = 0 ;
45213 int res1 = 0 ;
45214 unsigned int val2 ;
45215 int ecode2 = 0 ;
45216 PyObject * obj0 = 0 ;
45217 PyObject * obj1 = 0 ;
45218 PyObject * obj2 = 0 ;
45219 char * kwnames[] = {
45220 (char *) "self",(char *) "n",(char *) "clientData", NULL
45221 };
45222
45223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45225 if (!SWIG_IsOK(res1)) {
45226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45227 }
45228 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45229 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45230 if (!SWIG_IsOK(ecode2)) {
45231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45232 }
45233 arg2 = static_cast< unsigned int >(val2);
45234 arg3 = obj2;
45235 {
45236 PyThreadState* __tstate = wxPyBeginAllowThreads();
45237 wxItemContainer_SetClientData(arg1,arg2,arg3);
45238 wxPyEndAllowThreads(__tstate);
45239 if (PyErr_Occurred()) SWIG_fail;
45240 }
45241 resultobj = SWIG_Py_Void();
45242 return resultobj;
45243 fail:
45244 return NULL;
45245 }
45246
45247
45248 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45249 PyObject *resultobj = 0;
45250 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45251 unsigned int result;
45252 void *argp1 = 0 ;
45253 int res1 = 0 ;
45254 PyObject *swig_obj[1] ;
45255
45256 if (!args) SWIG_fail;
45257 swig_obj[0] = args;
45258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45259 if (!SWIG_IsOK(res1)) {
45260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45261 }
45262 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45263 {
45264 PyThreadState* __tstate = wxPyBeginAllowThreads();
45265 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45266 wxPyEndAllowThreads(__tstate);
45267 if (PyErr_Occurred()) SWIG_fail;
45268 }
45269 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45270 return resultobj;
45271 fail:
45272 return NULL;
45273 }
45274
45275
45276 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45277 PyObject *resultobj = 0;
45278 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45279 bool result;
45280 void *argp1 = 0 ;
45281 int res1 = 0 ;
45282 PyObject *swig_obj[1] ;
45283
45284 if (!args) SWIG_fail;
45285 swig_obj[0] = args;
45286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45287 if (!SWIG_IsOK(res1)) {
45288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45289 }
45290 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45291 {
45292 PyThreadState* __tstate = wxPyBeginAllowThreads();
45293 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45294 wxPyEndAllowThreads(__tstate);
45295 if (PyErr_Occurred()) SWIG_fail;
45296 }
45297 {
45298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45299 }
45300 return resultobj;
45301 fail:
45302 return NULL;
45303 }
45304
45305
45306 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45307 PyObject *resultobj = 0;
45308 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45309 unsigned int arg2 ;
45310 wxString result;
45311 void *argp1 = 0 ;
45312 int res1 = 0 ;
45313 unsigned int val2 ;
45314 int ecode2 = 0 ;
45315 PyObject * obj0 = 0 ;
45316 PyObject * obj1 = 0 ;
45317 char * kwnames[] = {
45318 (char *) "self",(char *) "n", NULL
45319 };
45320
45321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45323 if (!SWIG_IsOK(res1)) {
45324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45325 }
45326 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45327 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45328 if (!SWIG_IsOK(ecode2)) {
45329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45330 }
45331 arg2 = static_cast< unsigned int >(val2);
45332 {
45333 PyThreadState* __tstate = wxPyBeginAllowThreads();
45334 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45335 wxPyEndAllowThreads(__tstate);
45336 if (PyErr_Occurred()) SWIG_fail;
45337 }
45338 {
45339 #if wxUSE_UNICODE
45340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45341 #else
45342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45343 #endif
45344 }
45345 return resultobj;
45346 fail:
45347 return NULL;
45348 }
45349
45350
45351 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45352 PyObject *resultobj = 0;
45353 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45354 wxArrayString result;
45355 void *argp1 = 0 ;
45356 int res1 = 0 ;
45357 PyObject *swig_obj[1] ;
45358
45359 if (!args) SWIG_fail;
45360 swig_obj[0] = args;
45361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45362 if (!SWIG_IsOK(res1)) {
45363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45364 }
45365 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45366 {
45367 PyThreadState* __tstate = wxPyBeginAllowThreads();
45368 result = ((wxItemContainer const *)arg1)->GetStrings();
45369 wxPyEndAllowThreads(__tstate);
45370 if (PyErr_Occurred()) SWIG_fail;
45371 }
45372 {
45373 resultobj = wxArrayString2PyList_helper(result);
45374 }
45375 return resultobj;
45376 fail:
45377 return NULL;
45378 }
45379
45380
45381 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45382 PyObject *resultobj = 0;
45383 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45384 unsigned int arg2 ;
45385 wxString *arg3 = 0 ;
45386 void *argp1 = 0 ;
45387 int res1 = 0 ;
45388 unsigned int val2 ;
45389 int ecode2 = 0 ;
45390 bool temp3 = false ;
45391 PyObject * obj0 = 0 ;
45392 PyObject * obj1 = 0 ;
45393 PyObject * obj2 = 0 ;
45394 char * kwnames[] = {
45395 (char *) "self",(char *) "n",(char *) "s", NULL
45396 };
45397
45398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45400 if (!SWIG_IsOK(res1)) {
45401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45402 }
45403 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45404 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45405 if (!SWIG_IsOK(ecode2)) {
45406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45407 }
45408 arg2 = static_cast< unsigned int >(val2);
45409 {
45410 arg3 = wxString_in_helper(obj2);
45411 if (arg3 == NULL) SWIG_fail;
45412 temp3 = true;
45413 }
45414 {
45415 PyThreadState* __tstate = wxPyBeginAllowThreads();
45416 (arg1)->SetString(arg2,(wxString const &)*arg3);
45417 wxPyEndAllowThreads(__tstate);
45418 if (PyErr_Occurred()) SWIG_fail;
45419 }
45420 resultobj = SWIG_Py_Void();
45421 {
45422 if (temp3)
45423 delete arg3;
45424 }
45425 return resultobj;
45426 fail:
45427 {
45428 if (temp3)
45429 delete arg3;
45430 }
45431 return NULL;
45432 }
45433
45434
45435 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45436 PyObject *resultobj = 0;
45437 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45438 wxString *arg2 = 0 ;
45439 int result;
45440 void *argp1 = 0 ;
45441 int res1 = 0 ;
45442 bool temp2 = false ;
45443 PyObject * obj0 = 0 ;
45444 PyObject * obj1 = 0 ;
45445 char * kwnames[] = {
45446 (char *) "self",(char *) "s", NULL
45447 };
45448
45449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45451 if (!SWIG_IsOK(res1)) {
45452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45453 }
45454 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45455 {
45456 arg2 = wxString_in_helper(obj1);
45457 if (arg2 == NULL) SWIG_fail;
45458 temp2 = true;
45459 }
45460 {
45461 PyThreadState* __tstate = wxPyBeginAllowThreads();
45462 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45463 wxPyEndAllowThreads(__tstate);
45464 if (PyErr_Occurred()) SWIG_fail;
45465 }
45466 resultobj = SWIG_From_int(static_cast< int >(result));
45467 {
45468 if (temp2)
45469 delete arg2;
45470 }
45471 return resultobj;
45472 fail:
45473 {
45474 if (temp2)
45475 delete arg2;
45476 }
45477 return NULL;
45478 }
45479
45480
45481 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45482 PyObject *resultobj = 0;
45483 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45484 int arg2 ;
45485 void *argp1 = 0 ;
45486 int res1 = 0 ;
45487 int val2 ;
45488 int ecode2 = 0 ;
45489 PyObject * obj0 = 0 ;
45490 PyObject * obj1 = 0 ;
45491 char * kwnames[] = {
45492 (char *) "self",(char *) "n", NULL
45493 };
45494
45495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45497 if (!SWIG_IsOK(res1)) {
45498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45499 }
45500 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45501 ecode2 = SWIG_AsVal_int(obj1, &val2);
45502 if (!SWIG_IsOK(ecode2)) {
45503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45504 }
45505 arg2 = static_cast< int >(val2);
45506 {
45507 PyThreadState* __tstate = wxPyBeginAllowThreads();
45508 (arg1)->SetSelection(arg2);
45509 wxPyEndAllowThreads(__tstate);
45510 if (PyErr_Occurred()) SWIG_fail;
45511 }
45512 resultobj = SWIG_Py_Void();
45513 return resultobj;
45514 fail:
45515 return NULL;
45516 }
45517
45518
45519 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45520 PyObject *resultobj = 0;
45521 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45522 int result;
45523 void *argp1 = 0 ;
45524 int res1 = 0 ;
45525 PyObject *swig_obj[1] ;
45526
45527 if (!args) SWIG_fail;
45528 swig_obj[0] = args;
45529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45530 if (!SWIG_IsOK(res1)) {
45531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45532 }
45533 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45534 {
45535 PyThreadState* __tstate = wxPyBeginAllowThreads();
45536 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45537 wxPyEndAllowThreads(__tstate);
45538 if (PyErr_Occurred()) SWIG_fail;
45539 }
45540 resultobj = SWIG_From_int(static_cast< int >(result));
45541 return resultobj;
45542 fail:
45543 return NULL;
45544 }
45545
45546
45547 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45548 PyObject *resultobj = 0;
45549 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45550 wxString *arg2 = 0 ;
45551 bool result;
45552 void *argp1 = 0 ;
45553 int res1 = 0 ;
45554 bool temp2 = false ;
45555 PyObject * obj0 = 0 ;
45556 PyObject * obj1 = 0 ;
45557 char * kwnames[] = {
45558 (char *) "self",(char *) "s", NULL
45559 };
45560
45561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45563 if (!SWIG_IsOK(res1)) {
45564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45565 }
45566 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45567 {
45568 arg2 = wxString_in_helper(obj1);
45569 if (arg2 == NULL) SWIG_fail;
45570 temp2 = true;
45571 }
45572 {
45573 PyThreadState* __tstate = wxPyBeginAllowThreads();
45574 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45575 wxPyEndAllowThreads(__tstate);
45576 if (PyErr_Occurred()) SWIG_fail;
45577 }
45578 {
45579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45580 }
45581 {
45582 if (temp2)
45583 delete arg2;
45584 }
45585 return resultobj;
45586 fail:
45587 {
45588 if (temp2)
45589 delete arg2;
45590 }
45591 return NULL;
45592 }
45593
45594
45595 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45596 PyObject *resultobj = 0;
45597 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45598 wxString result;
45599 void *argp1 = 0 ;
45600 int res1 = 0 ;
45601 PyObject *swig_obj[1] ;
45602
45603 if (!args) SWIG_fail;
45604 swig_obj[0] = args;
45605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45606 if (!SWIG_IsOK(res1)) {
45607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45608 }
45609 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45610 {
45611 PyThreadState* __tstate = wxPyBeginAllowThreads();
45612 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45613 wxPyEndAllowThreads(__tstate);
45614 if (PyErr_Occurred()) SWIG_fail;
45615 }
45616 {
45617 #if wxUSE_UNICODE
45618 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45619 #else
45620 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45621 #endif
45622 }
45623 return resultobj;
45624 fail:
45625 return NULL;
45626 }
45627
45628
45629 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45630 PyObject *resultobj = 0;
45631 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45632 int arg2 ;
45633 void *argp1 = 0 ;
45634 int res1 = 0 ;
45635 int val2 ;
45636 int ecode2 = 0 ;
45637 PyObject * obj0 = 0 ;
45638 PyObject * obj1 = 0 ;
45639 char * kwnames[] = {
45640 (char *) "self",(char *) "n", NULL
45641 };
45642
45643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45645 if (!SWIG_IsOK(res1)) {
45646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45647 }
45648 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45649 ecode2 = SWIG_AsVal_int(obj1, &val2);
45650 if (!SWIG_IsOK(ecode2)) {
45651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45652 }
45653 arg2 = static_cast< int >(val2);
45654 {
45655 PyThreadState* __tstate = wxPyBeginAllowThreads();
45656 (arg1)->Select(arg2);
45657 wxPyEndAllowThreads(__tstate);
45658 if (PyErr_Occurred()) SWIG_fail;
45659 }
45660 resultobj = SWIG_Py_Void();
45661 return resultobj;
45662 fail:
45663 return NULL;
45664 }
45665
45666
45667 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45668 PyObject *obj;
45669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45670 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45671 return SWIG_Py_Void();
45672 }
45673
45674 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45675 PyObject *obj;
45676 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45677 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45678 return SWIG_Py_Void();
45679 }
45680
45681 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45682 PyObject *resultobj = 0;
45683 wxSizerItem *result = 0 ;
45684
45685 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45686 {
45687 PyThreadState* __tstate = wxPyBeginAllowThreads();
45688 result = (wxSizerItem *)new wxSizerItem();
45689 wxPyEndAllowThreads(__tstate);
45690 if (PyErr_Occurred()) SWIG_fail;
45691 }
45692 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45693 return resultobj;
45694 fail:
45695 return NULL;
45696 }
45697
45698
45699 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45700 PyObject *resultobj = 0;
45701 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45702 void *argp1 = 0 ;
45703 int res1 = 0 ;
45704 PyObject *swig_obj[1] ;
45705
45706 if (!args) SWIG_fail;
45707 swig_obj[0] = args;
45708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45709 if (!SWIG_IsOK(res1)) {
45710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45711 }
45712 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45713 {
45714 PyThreadState* __tstate = wxPyBeginAllowThreads();
45715 delete arg1;
45716
45717 wxPyEndAllowThreads(__tstate);
45718 if (PyErr_Occurred()) SWIG_fail;
45719 }
45720 resultobj = SWIG_Py_Void();
45721 return resultobj;
45722 fail:
45723 return NULL;
45724 }
45725
45726
45727 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45728 PyObject *resultobj = 0;
45729 wxWindow *arg1 = (wxWindow *) 0 ;
45730 int arg2 ;
45731 int arg3 ;
45732 int arg4 ;
45733 PyObject *arg5 = (PyObject *) NULL ;
45734 wxSizerItem *result = 0 ;
45735 void *argp1 = 0 ;
45736 int res1 = 0 ;
45737 int val2 ;
45738 int ecode2 = 0 ;
45739 int val3 ;
45740 int ecode3 = 0 ;
45741 int val4 ;
45742 int ecode4 = 0 ;
45743 PyObject * obj0 = 0 ;
45744 PyObject * obj1 = 0 ;
45745 PyObject * obj2 = 0 ;
45746 PyObject * obj3 = 0 ;
45747 PyObject * obj4 = 0 ;
45748 char * kwnames[] = {
45749 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45750 };
45751
45752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45754 if (!SWIG_IsOK(res1)) {
45755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45756 }
45757 arg1 = reinterpret_cast< wxWindow * >(argp1);
45758 ecode2 = SWIG_AsVal_int(obj1, &val2);
45759 if (!SWIG_IsOK(ecode2)) {
45760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45761 }
45762 arg2 = static_cast< int >(val2);
45763 ecode3 = SWIG_AsVal_int(obj2, &val3);
45764 if (!SWIG_IsOK(ecode3)) {
45765 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45766 }
45767 arg3 = static_cast< int >(val3);
45768 ecode4 = SWIG_AsVal_int(obj3, &val4);
45769 if (!SWIG_IsOK(ecode4)) {
45770 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45771 }
45772 arg4 = static_cast< int >(val4);
45773 if (obj4) {
45774 arg5 = obj4;
45775 }
45776 {
45777 PyThreadState* __tstate = wxPyBeginAllowThreads();
45778 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45779 wxPyEndAllowThreads(__tstate);
45780 if (PyErr_Occurred()) SWIG_fail;
45781 }
45782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45783 return resultobj;
45784 fail:
45785 return NULL;
45786 }
45787
45788
45789 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45790 PyObject *resultobj = 0;
45791 int arg1 ;
45792 int arg2 ;
45793 int arg3 ;
45794 int arg4 ;
45795 int arg5 ;
45796 PyObject *arg6 = (PyObject *) NULL ;
45797 wxSizerItem *result = 0 ;
45798 int val1 ;
45799 int ecode1 = 0 ;
45800 int val2 ;
45801 int ecode2 = 0 ;
45802 int val3 ;
45803 int ecode3 = 0 ;
45804 int val4 ;
45805 int ecode4 = 0 ;
45806 int val5 ;
45807 int ecode5 = 0 ;
45808 PyObject * obj0 = 0 ;
45809 PyObject * obj1 = 0 ;
45810 PyObject * obj2 = 0 ;
45811 PyObject * obj3 = 0 ;
45812 PyObject * obj4 = 0 ;
45813 PyObject * obj5 = 0 ;
45814 char * kwnames[] = {
45815 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45816 };
45817
45818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45819 ecode1 = SWIG_AsVal_int(obj0, &val1);
45820 if (!SWIG_IsOK(ecode1)) {
45821 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45822 }
45823 arg1 = static_cast< int >(val1);
45824 ecode2 = SWIG_AsVal_int(obj1, &val2);
45825 if (!SWIG_IsOK(ecode2)) {
45826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45827 }
45828 arg2 = static_cast< int >(val2);
45829 ecode3 = SWIG_AsVal_int(obj2, &val3);
45830 if (!SWIG_IsOK(ecode3)) {
45831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45832 }
45833 arg3 = static_cast< int >(val3);
45834 ecode4 = SWIG_AsVal_int(obj3, &val4);
45835 if (!SWIG_IsOK(ecode4)) {
45836 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45837 }
45838 arg4 = static_cast< int >(val4);
45839 ecode5 = SWIG_AsVal_int(obj4, &val5);
45840 if (!SWIG_IsOK(ecode5)) {
45841 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45842 }
45843 arg5 = static_cast< int >(val5);
45844 if (obj5) {
45845 arg6 = obj5;
45846 }
45847 {
45848 PyThreadState* __tstate = wxPyBeginAllowThreads();
45849 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45850 wxPyEndAllowThreads(__tstate);
45851 if (PyErr_Occurred()) SWIG_fail;
45852 }
45853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45854 return resultobj;
45855 fail:
45856 return NULL;
45857 }
45858
45859
45860 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45861 PyObject *resultobj = 0;
45862 wxSizer *arg1 = (wxSizer *) 0 ;
45863 int arg2 ;
45864 int arg3 ;
45865 int arg4 ;
45866 PyObject *arg5 = (PyObject *) NULL ;
45867 wxSizerItem *result = 0 ;
45868 int res1 = 0 ;
45869 int val2 ;
45870 int ecode2 = 0 ;
45871 int val3 ;
45872 int ecode3 = 0 ;
45873 int val4 ;
45874 int ecode4 = 0 ;
45875 PyObject * obj0 = 0 ;
45876 PyObject * obj1 = 0 ;
45877 PyObject * obj2 = 0 ;
45878 PyObject * obj3 = 0 ;
45879 PyObject * obj4 = 0 ;
45880 char * kwnames[] = {
45881 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45882 };
45883
45884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45885 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45886 if (!SWIG_IsOK(res1)) {
45887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45888 }
45889 ecode2 = SWIG_AsVal_int(obj1, &val2);
45890 if (!SWIG_IsOK(ecode2)) {
45891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45892 }
45893 arg2 = static_cast< int >(val2);
45894 ecode3 = SWIG_AsVal_int(obj2, &val3);
45895 if (!SWIG_IsOK(ecode3)) {
45896 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45897 }
45898 arg3 = static_cast< int >(val3);
45899 ecode4 = SWIG_AsVal_int(obj3, &val4);
45900 if (!SWIG_IsOK(ecode4)) {
45901 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45902 }
45903 arg4 = static_cast< int >(val4);
45904 if (obj4) {
45905 arg5 = obj4;
45906 }
45907 {
45908 PyThreadState* __tstate = wxPyBeginAllowThreads();
45909 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45910 wxPyEndAllowThreads(__tstate);
45911 if (PyErr_Occurred()) SWIG_fail;
45912 }
45913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45914 return resultobj;
45915 fail:
45916 return NULL;
45917 }
45918
45919
45920 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45921 PyObject *resultobj = 0;
45922 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45923 void *argp1 = 0 ;
45924 int res1 = 0 ;
45925 PyObject *swig_obj[1] ;
45926
45927 if (!args) SWIG_fail;
45928 swig_obj[0] = args;
45929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45930 if (!SWIG_IsOK(res1)) {
45931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45932 }
45933 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45934 {
45935 PyThreadState* __tstate = wxPyBeginAllowThreads();
45936 (arg1)->DeleteWindows();
45937 wxPyEndAllowThreads(__tstate);
45938 if (PyErr_Occurred()) SWIG_fail;
45939 }
45940 resultobj = SWIG_Py_Void();
45941 return resultobj;
45942 fail:
45943 return NULL;
45944 }
45945
45946
45947 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45948 PyObject *resultobj = 0;
45949 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45950 void *argp1 = 0 ;
45951 int res1 = 0 ;
45952 PyObject *swig_obj[1] ;
45953
45954 if (!args) SWIG_fail;
45955 swig_obj[0] = args;
45956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45957 if (!SWIG_IsOK(res1)) {
45958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45959 }
45960 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45961 {
45962 PyThreadState* __tstate = wxPyBeginAllowThreads();
45963 (arg1)->DetachSizer();
45964 wxPyEndAllowThreads(__tstate);
45965 if (PyErr_Occurred()) SWIG_fail;
45966 }
45967 resultobj = SWIG_Py_Void();
45968 return resultobj;
45969 fail:
45970 return NULL;
45971 }
45972
45973
45974 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45975 PyObject *resultobj = 0;
45976 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45977 wxSize result;
45978 void *argp1 = 0 ;
45979 int res1 = 0 ;
45980 PyObject *swig_obj[1] ;
45981
45982 if (!args) SWIG_fail;
45983 swig_obj[0] = args;
45984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45985 if (!SWIG_IsOK(res1)) {
45986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45987 }
45988 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45989 {
45990 PyThreadState* __tstate = wxPyBeginAllowThreads();
45991 result = (arg1)->GetSize();
45992 wxPyEndAllowThreads(__tstate);
45993 if (PyErr_Occurred()) SWIG_fail;
45994 }
45995 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45996 return resultobj;
45997 fail:
45998 return NULL;
45999 }
46000
46001
46002 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46003 PyObject *resultobj = 0;
46004 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46005 wxSize result;
46006 void *argp1 = 0 ;
46007 int res1 = 0 ;
46008 PyObject *swig_obj[1] ;
46009
46010 if (!args) SWIG_fail;
46011 swig_obj[0] = args;
46012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46013 if (!SWIG_IsOK(res1)) {
46014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46015 }
46016 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46017 {
46018 PyThreadState* __tstate = wxPyBeginAllowThreads();
46019 result = (arg1)->CalcMin();
46020 wxPyEndAllowThreads(__tstate);
46021 if (PyErr_Occurred()) SWIG_fail;
46022 }
46023 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46024 return resultobj;
46025 fail:
46026 return NULL;
46027 }
46028
46029
46030 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46031 PyObject *resultobj = 0;
46032 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46033 wxPoint *arg2 = 0 ;
46034 wxSize *arg3 = 0 ;
46035 void *argp1 = 0 ;
46036 int res1 = 0 ;
46037 wxPoint temp2 ;
46038 wxSize temp3 ;
46039 PyObject * obj0 = 0 ;
46040 PyObject * obj1 = 0 ;
46041 PyObject * obj2 = 0 ;
46042 char * kwnames[] = {
46043 (char *) "self",(char *) "pos",(char *) "size", NULL
46044 };
46045
46046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46048 if (!SWIG_IsOK(res1)) {
46049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46050 }
46051 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46052 {
46053 arg2 = &temp2;
46054 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46055 }
46056 {
46057 arg3 = &temp3;
46058 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46059 }
46060 {
46061 PyThreadState* __tstate = wxPyBeginAllowThreads();
46062 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46063 wxPyEndAllowThreads(__tstate);
46064 if (PyErr_Occurred()) SWIG_fail;
46065 }
46066 resultobj = SWIG_Py_Void();
46067 return resultobj;
46068 fail:
46069 return NULL;
46070 }
46071
46072
46073 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46074 PyObject *resultobj = 0;
46075 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46076 wxSize result;
46077 void *argp1 = 0 ;
46078 int res1 = 0 ;
46079 PyObject *swig_obj[1] ;
46080
46081 if (!args) SWIG_fail;
46082 swig_obj[0] = args;
46083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46084 if (!SWIG_IsOK(res1)) {
46085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46086 }
46087 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46088 {
46089 PyThreadState* __tstate = wxPyBeginAllowThreads();
46090 result = (arg1)->GetMinSize();
46091 wxPyEndAllowThreads(__tstate);
46092 if (PyErr_Occurred()) SWIG_fail;
46093 }
46094 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46095 return resultobj;
46096 fail:
46097 return NULL;
46098 }
46099
46100
46101 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46102 PyObject *resultobj = 0;
46103 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46104 wxSize result;
46105 void *argp1 = 0 ;
46106 int res1 = 0 ;
46107 PyObject *swig_obj[1] ;
46108
46109 if (!args) SWIG_fail;
46110 swig_obj[0] = args;
46111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46112 if (!SWIG_IsOK(res1)) {
46113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46114 }
46115 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46116 {
46117 PyThreadState* __tstate = wxPyBeginAllowThreads();
46118 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46119 wxPyEndAllowThreads(__tstate);
46120 if (PyErr_Occurred()) SWIG_fail;
46121 }
46122 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46123 return resultobj;
46124 fail:
46125 return NULL;
46126 }
46127
46128
46129 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46130 PyObject *resultobj = 0;
46131 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46132 int arg2 ;
46133 int arg3 ;
46134 void *argp1 = 0 ;
46135 int res1 = 0 ;
46136 int val2 ;
46137 int ecode2 = 0 ;
46138 int val3 ;
46139 int ecode3 = 0 ;
46140 PyObject * obj0 = 0 ;
46141 PyObject * obj1 = 0 ;
46142 PyObject * obj2 = 0 ;
46143 char * kwnames[] = {
46144 (char *) "self",(char *) "x",(char *) "y", NULL
46145 };
46146
46147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46149 if (!SWIG_IsOK(res1)) {
46150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46151 }
46152 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46153 ecode2 = SWIG_AsVal_int(obj1, &val2);
46154 if (!SWIG_IsOK(ecode2)) {
46155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46156 }
46157 arg2 = static_cast< int >(val2);
46158 ecode3 = SWIG_AsVal_int(obj2, &val3);
46159 if (!SWIG_IsOK(ecode3)) {
46160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46161 }
46162 arg3 = static_cast< int >(val3);
46163 {
46164 PyThreadState* __tstate = wxPyBeginAllowThreads();
46165 (arg1)->SetInitSize(arg2,arg3);
46166 wxPyEndAllowThreads(__tstate);
46167 if (PyErr_Occurred()) SWIG_fail;
46168 }
46169 resultobj = SWIG_Py_Void();
46170 return resultobj;
46171 fail:
46172 return NULL;
46173 }
46174
46175
46176 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46177 PyObject *resultobj = 0;
46178 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46179 int arg2 ;
46180 int arg3 ;
46181 void *argp1 = 0 ;
46182 int res1 = 0 ;
46183 int val2 ;
46184 int ecode2 = 0 ;
46185 int val3 ;
46186 int ecode3 = 0 ;
46187 PyObject * obj0 = 0 ;
46188 PyObject * obj1 = 0 ;
46189 PyObject * obj2 = 0 ;
46190 char * kwnames[] = {
46191 (char *) "self",(char *) "width",(char *) "height", NULL
46192 };
46193
46194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) 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_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46198 }
46199 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46200 ecode2 = SWIG_AsVal_int(obj1, &val2);
46201 if (!SWIG_IsOK(ecode2)) {
46202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46203 }
46204 arg2 = static_cast< int >(val2);
46205 ecode3 = SWIG_AsVal_int(obj2, &val3);
46206 if (!SWIG_IsOK(ecode3)) {
46207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46208 }
46209 arg3 = static_cast< int >(val3);
46210 {
46211 PyThreadState* __tstate = wxPyBeginAllowThreads();
46212 (arg1)->SetRatio(arg2,arg3);
46213 wxPyEndAllowThreads(__tstate);
46214 if (PyErr_Occurred()) SWIG_fail;
46215 }
46216 resultobj = SWIG_Py_Void();
46217 return resultobj;
46218 fail:
46219 return NULL;
46220 }
46221
46222
46223 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46224 PyObject *resultobj = 0;
46225 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46226 wxSize *arg2 = 0 ;
46227 void *argp1 = 0 ;
46228 int res1 = 0 ;
46229 wxSize temp2 ;
46230 PyObject * obj0 = 0 ;
46231 PyObject * obj1 = 0 ;
46232 char * kwnames[] = {
46233 (char *) "self",(char *) "size", NULL
46234 };
46235
46236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46238 if (!SWIG_IsOK(res1)) {
46239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46240 }
46241 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46242 {
46243 arg2 = &temp2;
46244 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46245 }
46246 {
46247 PyThreadState* __tstate = wxPyBeginAllowThreads();
46248 (arg1)->SetRatio((wxSize const &)*arg2);
46249 wxPyEndAllowThreads(__tstate);
46250 if (PyErr_Occurred()) SWIG_fail;
46251 }
46252 resultobj = SWIG_Py_Void();
46253 return resultobj;
46254 fail:
46255 return NULL;
46256 }
46257
46258
46259 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46260 PyObject *resultobj = 0;
46261 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46262 float arg2 ;
46263 void *argp1 = 0 ;
46264 int res1 = 0 ;
46265 float val2 ;
46266 int ecode2 = 0 ;
46267 PyObject * obj0 = 0 ;
46268 PyObject * obj1 = 0 ;
46269 char * kwnames[] = {
46270 (char *) "self",(char *) "ratio", NULL
46271 };
46272
46273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46275 if (!SWIG_IsOK(res1)) {
46276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46277 }
46278 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46279 ecode2 = SWIG_AsVal_float(obj1, &val2);
46280 if (!SWIG_IsOK(ecode2)) {
46281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46282 }
46283 arg2 = static_cast< float >(val2);
46284 {
46285 PyThreadState* __tstate = wxPyBeginAllowThreads();
46286 (arg1)->SetRatio(arg2);
46287 wxPyEndAllowThreads(__tstate);
46288 if (PyErr_Occurred()) SWIG_fail;
46289 }
46290 resultobj = SWIG_Py_Void();
46291 return resultobj;
46292 fail:
46293 return NULL;
46294 }
46295
46296
46297 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46298 PyObject *resultobj = 0;
46299 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46300 float result;
46301 void *argp1 = 0 ;
46302 int res1 = 0 ;
46303 PyObject *swig_obj[1] ;
46304
46305 if (!args) SWIG_fail;
46306 swig_obj[0] = args;
46307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46308 if (!SWIG_IsOK(res1)) {
46309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46310 }
46311 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46312 {
46313 PyThreadState* __tstate = wxPyBeginAllowThreads();
46314 result = (float)(arg1)->GetRatio();
46315 wxPyEndAllowThreads(__tstate);
46316 if (PyErr_Occurred()) SWIG_fail;
46317 }
46318 resultobj = SWIG_From_float(static_cast< float >(result));
46319 return resultobj;
46320 fail:
46321 return NULL;
46322 }
46323
46324
46325 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46326 PyObject *resultobj = 0;
46327 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46328 wxRect result;
46329 void *argp1 = 0 ;
46330 int res1 = 0 ;
46331 PyObject *swig_obj[1] ;
46332
46333 if (!args) SWIG_fail;
46334 swig_obj[0] = args;
46335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46336 if (!SWIG_IsOK(res1)) {
46337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46338 }
46339 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46340 {
46341 PyThreadState* __tstate = wxPyBeginAllowThreads();
46342 result = (arg1)->GetRect();
46343 wxPyEndAllowThreads(__tstate);
46344 if (PyErr_Occurred()) SWIG_fail;
46345 }
46346 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46347 return resultobj;
46348 fail:
46349 return NULL;
46350 }
46351
46352
46353 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46354 PyObject *resultobj = 0;
46355 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46356 bool result;
46357 void *argp1 = 0 ;
46358 int res1 = 0 ;
46359 PyObject *swig_obj[1] ;
46360
46361 if (!args) SWIG_fail;
46362 swig_obj[0] = args;
46363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46364 if (!SWIG_IsOK(res1)) {
46365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46366 }
46367 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46368 {
46369 PyThreadState* __tstate = wxPyBeginAllowThreads();
46370 result = (bool)(arg1)->IsWindow();
46371 wxPyEndAllowThreads(__tstate);
46372 if (PyErr_Occurred()) SWIG_fail;
46373 }
46374 {
46375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46376 }
46377 return resultobj;
46378 fail:
46379 return NULL;
46380 }
46381
46382
46383 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46384 PyObject *resultobj = 0;
46385 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46386 bool result;
46387 void *argp1 = 0 ;
46388 int res1 = 0 ;
46389 PyObject *swig_obj[1] ;
46390
46391 if (!args) SWIG_fail;
46392 swig_obj[0] = args;
46393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46394 if (!SWIG_IsOK(res1)) {
46395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46396 }
46397 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46398 {
46399 PyThreadState* __tstate = wxPyBeginAllowThreads();
46400 result = (bool)(arg1)->IsSizer();
46401 wxPyEndAllowThreads(__tstate);
46402 if (PyErr_Occurred()) SWIG_fail;
46403 }
46404 {
46405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46406 }
46407 return resultobj;
46408 fail:
46409 return NULL;
46410 }
46411
46412
46413 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46414 PyObject *resultobj = 0;
46415 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46416 bool result;
46417 void *argp1 = 0 ;
46418 int res1 = 0 ;
46419 PyObject *swig_obj[1] ;
46420
46421 if (!args) SWIG_fail;
46422 swig_obj[0] = args;
46423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46424 if (!SWIG_IsOK(res1)) {
46425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46426 }
46427 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46428 {
46429 PyThreadState* __tstate = wxPyBeginAllowThreads();
46430 result = (bool)(arg1)->IsSpacer();
46431 wxPyEndAllowThreads(__tstate);
46432 if (PyErr_Occurred()) SWIG_fail;
46433 }
46434 {
46435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46436 }
46437 return resultobj;
46438 fail:
46439 return NULL;
46440 }
46441
46442
46443 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46444 PyObject *resultobj = 0;
46445 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46446 int arg2 ;
46447 void *argp1 = 0 ;
46448 int res1 = 0 ;
46449 int val2 ;
46450 int ecode2 = 0 ;
46451 PyObject * obj0 = 0 ;
46452 PyObject * obj1 = 0 ;
46453 char * kwnames[] = {
46454 (char *) "self",(char *) "proportion", NULL
46455 };
46456
46457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46459 if (!SWIG_IsOK(res1)) {
46460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46461 }
46462 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46463 ecode2 = SWIG_AsVal_int(obj1, &val2);
46464 if (!SWIG_IsOK(ecode2)) {
46465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46466 }
46467 arg2 = static_cast< int >(val2);
46468 {
46469 PyThreadState* __tstate = wxPyBeginAllowThreads();
46470 (arg1)->SetProportion(arg2);
46471 wxPyEndAllowThreads(__tstate);
46472 if (PyErr_Occurred()) SWIG_fail;
46473 }
46474 resultobj = SWIG_Py_Void();
46475 return resultobj;
46476 fail:
46477 return NULL;
46478 }
46479
46480
46481 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46482 PyObject *resultobj = 0;
46483 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46484 int result;
46485 void *argp1 = 0 ;
46486 int res1 = 0 ;
46487 PyObject *swig_obj[1] ;
46488
46489 if (!args) SWIG_fail;
46490 swig_obj[0] = args;
46491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46492 if (!SWIG_IsOK(res1)) {
46493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46494 }
46495 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46496 {
46497 PyThreadState* __tstate = wxPyBeginAllowThreads();
46498 result = (int)(arg1)->GetProportion();
46499 wxPyEndAllowThreads(__tstate);
46500 if (PyErr_Occurred()) SWIG_fail;
46501 }
46502 resultobj = SWIG_From_int(static_cast< int >(result));
46503 return resultobj;
46504 fail:
46505 return NULL;
46506 }
46507
46508
46509 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46510 PyObject *resultobj = 0;
46511 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46512 int arg2 ;
46513 void *argp1 = 0 ;
46514 int res1 = 0 ;
46515 int val2 ;
46516 int ecode2 = 0 ;
46517 PyObject * obj0 = 0 ;
46518 PyObject * obj1 = 0 ;
46519 char * kwnames[] = {
46520 (char *) "self",(char *) "flag", NULL
46521 };
46522
46523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46525 if (!SWIG_IsOK(res1)) {
46526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46527 }
46528 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46529 ecode2 = SWIG_AsVal_int(obj1, &val2);
46530 if (!SWIG_IsOK(ecode2)) {
46531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46532 }
46533 arg2 = static_cast< int >(val2);
46534 {
46535 PyThreadState* __tstate = wxPyBeginAllowThreads();
46536 (arg1)->SetFlag(arg2);
46537 wxPyEndAllowThreads(__tstate);
46538 if (PyErr_Occurred()) SWIG_fail;
46539 }
46540 resultobj = SWIG_Py_Void();
46541 return resultobj;
46542 fail:
46543 return NULL;
46544 }
46545
46546
46547 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46548 PyObject *resultobj = 0;
46549 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46550 int result;
46551 void *argp1 = 0 ;
46552 int res1 = 0 ;
46553 PyObject *swig_obj[1] ;
46554
46555 if (!args) SWIG_fail;
46556 swig_obj[0] = args;
46557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46558 if (!SWIG_IsOK(res1)) {
46559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46560 }
46561 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46562 {
46563 PyThreadState* __tstate = wxPyBeginAllowThreads();
46564 result = (int)(arg1)->GetFlag();
46565 wxPyEndAllowThreads(__tstate);
46566 if (PyErr_Occurred()) SWIG_fail;
46567 }
46568 resultobj = SWIG_From_int(static_cast< int >(result));
46569 return resultobj;
46570 fail:
46571 return NULL;
46572 }
46573
46574
46575 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46576 PyObject *resultobj = 0;
46577 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46578 int arg2 ;
46579 void *argp1 = 0 ;
46580 int res1 = 0 ;
46581 int val2 ;
46582 int ecode2 = 0 ;
46583 PyObject * obj0 = 0 ;
46584 PyObject * obj1 = 0 ;
46585 char * kwnames[] = {
46586 (char *) "self",(char *) "border", NULL
46587 };
46588
46589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46591 if (!SWIG_IsOK(res1)) {
46592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46593 }
46594 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46595 ecode2 = SWIG_AsVal_int(obj1, &val2);
46596 if (!SWIG_IsOK(ecode2)) {
46597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46598 }
46599 arg2 = static_cast< int >(val2);
46600 {
46601 PyThreadState* __tstate = wxPyBeginAllowThreads();
46602 (arg1)->SetBorder(arg2);
46603 wxPyEndAllowThreads(__tstate);
46604 if (PyErr_Occurred()) SWIG_fail;
46605 }
46606 resultobj = SWIG_Py_Void();
46607 return resultobj;
46608 fail:
46609 return NULL;
46610 }
46611
46612
46613 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46614 PyObject *resultobj = 0;
46615 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46616 int result;
46617 void *argp1 = 0 ;
46618 int res1 = 0 ;
46619 PyObject *swig_obj[1] ;
46620
46621 if (!args) SWIG_fail;
46622 swig_obj[0] = args;
46623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46624 if (!SWIG_IsOK(res1)) {
46625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46626 }
46627 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46628 {
46629 PyThreadState* __tstate = wxPyBeginAllowThreads();
46630 result = (int)(arg1)->GetBorder();
46631 wxPyEndAllowThreads(__tstate);
46632 if (PyErr_Occurred()) SWIG_fail;
46633 }
46634 resultobj = SWIG_From_int(static_cast< int >(result));
46635 return resultobj;
46636 fail:
46637 return NULL;
46638 }
46639
46640
46641 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46642 PyObject *resultobj = 0;
46643 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46644 wxWindow *result = 0 ;
46645 void *argp1 = 0 ;
46646 int res1 = 0 ;
46647 PyObject *swig_obj[1] ;
46648
46649 if (!args) SWIG_fail;
46650 swig_obj[0] = args;
46651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46652 if (!SWIG_IsOK(res1)) {
46653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46654 }
46655 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46656 {
46657 PyThreadState* __tstate = wxPyBeginAllowThreads();
46658 result = (wxWindow *)(arg1)->GetWindow();
46659 wxPyEndAllowThreads(__tstate);
46660 if (PyErr_Occurred()) SWIG_fail;
46661 }
46662 {
46663 resultobj = wxPyMake_wxObject(result, 0);
46664 }
46665 return resultobj;
46666 fail:
46667 return NULL;
46668 }
46669
46670
46671 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46672 PyObject *resultobj = 0;
46673 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46674 wxWindow *arg2 = (wxWindow *) 0 ;
46675 void *argp1 = 0 ;
46676 int res1 = 0 ;
46677 void *argp2 = 0 ;
46678 int res2 = 0 ;
46679 PyObject * obj0 = 0 ;
46680 PyObject * obj1 = 0 ;
46681 char * kwnames[] = {
46682 (char *) "self",(char *) "window", NULL
46683 };
46684
46685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46687 if (!SWIG_IsOK(res1)) {
46688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46689 }
46690 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46691 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46692 if (!SWIG_IsOK(res2)) {
46693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46694 }
46695 arg2 = reinterpret_cast< wxWindow * >(argp2);
46696 {
46697 PyThreadState* __tstate = wxPyBeginAllowThreads();
46698 (arg1)->SetWindow(arg2);
46699 wxPyEndAllowThreads(__tstate);
46700 if (PyErr_Occurred()) SWIG_fail;
46701 }
46702 resultobj = SWIG_Py_Void();
46703 return resultobj;
46704 fail:
46705 return NULL;
46706 }
46707
46708
46709 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46710 PyObject *resultobj = 0;
46711 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46712 wxSizer *result = 0 ;
46713 void *argp1 = 0 ;
46714 int res1 = 0 ;
46715 PyObject *swig_obj[1] ;
46716
46717 if (!args) SWIG_fail;
46718 swig_obj[0] = args;
46719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46720 if (!SWIG_IsOK(res1)) {
46721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46722 }
46723 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46724 {
46725 PyThreadState* __tstate = wxPyBeginAllowThreads();
46726 result = (wxSizer *)(arg1)->GetSizer();
46727 wxPyEndAllowThreads(__tstate);
46728 if (PyErr_Occurred()) SWIG_fail;
46729 }
46730 {
46731 resultobj = wxPyMake_wxObject(result, (bool)0);
46732 }
46733 return resultobj;
46734 fail:
46735 return NULL;
46736 }
46737
46738
46739 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46740 PyObject *resultobj = 0;
46741 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46742 wxSizer *arg2 = (wxSizer *) 0 ;
46743 void *argp1 = 0 ;
46744 int res1 = 0 ;
46745 int res2 = 0 ;
46746 PyObject * obj0 = 0 ;
46747 PyObject * obj1 = 0 ;
46748 char * kwnames[] = {
46749 (char *) "self",(char *) "sizer", NULL
46750 };
46751
46752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46754 if (!SWIG_IsOK(res1)) {
46755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46756 }
46757 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46758 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46759 if (!SWIG_IsOK(res2)) {
46760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46761 }
46762 {
46763 PyThreadState* __tstate = wxPyBeginAllowThreads();
46764 (arg1)->SetSizer(arg2);
46765 wxPyEndAllowThreads(__tstate);
46766 if (PyErr_Occurred()) SWIG_fail;
46767 }
46768 resultobj = SWIG_Py_Void();
46769 return resultobj;
46770 fail:
46771 return NULL;
46772 }
46773
46774
46775 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46776 PyObject *resultobj = 0;
46777 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46778 wxSize *result = 0 ;
46779 void *argp1 = 0 ;
46780 int res1 = 0 ;
46781 PyObject *swig_obj[1] ;
46782
46783 if (!args) SWIG_fail;
46784 swig_obj[0] = args;
46785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46786 if (!SWIG_IsOK(res1)) {
46787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46788 }
46789 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46790 {
46791 PyThreadState* __tstate = wxPyBeginAllowThreads();
46792 {
46793 wxSize const &_result_ref = (arg1)->GetSpacer();
46794 result = (wxSize *) &_result_ref;
46795 }
46796 wxPyEndAllowThreads(__tstate);
46797 if (PyErr_Occurred()) SWIG_fail;
46798 }
46799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46800 return resultobj;
46801 fail:
46802 return NULL;
46803 }
46804
46805
46806 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46807 PyObject *resultobj = 0;
46808 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46809 wxSize *arg2 = 0 ;
46810 void *argp1 = 0 ;
46811 int res1 = 0 ;
46812 wxSize temp2 ;
46813 PyObject * obj0 = 0 ;
46814 PyObject * obj1 = 0 ;
46815 char * kwnames[] = {
46816 (char *) "self",(char *) "size", NULL
46817 };
46818
46819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46821 if (!SWIG_IsOK(res1)) {
46822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46823 }
46824 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46825 {
46826 arg2 = &temp2;
46827 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46828 }
46829 {
46830 PyThreadState* __tstate = wxPyBeginAllowThreads();
46831 (arg1)->SetSpacer((wxSize const &)*arg2);
46832 wxPyEndAllowThreads(__tstate);
46833 if (PyErr_Occurred()) SWIG_fail;
46834 }
46835 resultobj = SWIG_Py_Void();
46836 return resultobj;
46837 fail:
46838 return NULL;
46839 }
46840
46841
46842 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46843 PyObject *resultobj = 0;
46844 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46845 bool arg2 ;
46846 void *argp1 = 0 ;
46847 int res1 = 0 ;
46848 bool val2 ;
46849 int ecode2 = 0 ;
46850 PyObject * obj0 = 0 ;
46851 PyObject * obj1 = 0 ;
46852 char * kwnames[] = {
46853 (char *) "self",(char *) "show", NULL
46854 };
46855
46856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46858 if (!SWIG_IsOK(res1)) {
46859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46860 }
46861 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46862 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46863 if (!SWIG_IsOK(ecode2)) {
46864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46865 }
46866 arg2 = static_cast< bool >(val2);
46867 {
46868 PyThreadState* __tstate = wxPyBeginAllowThreads();
46869 (arg1)->Show(arg2);
46870 wxPyEndAllowThreads(__tstate);
46871 if (PyErr_Occurred()) SWIG_fail;
46872 }
46873 resultobj = SWIG_Py_Void();
46874 return resultobj;
46875 fail:
46876 return NULL;
46877 }
46878
46879
46880 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46881 PyObject *resultobj = 0;
46882 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46883 bool result;
46884 void *argp1 = 0 ;
46885 int res1 = 0 ;
46886 PyObject *swig_obj[1] ;
46887
46888 if (!args) SWIG_fail;
46889 swig_obj[0] = args;
46890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46891 if (!SWIG_IsOK(res1)) {
46892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46893 }
46894 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46895 {
46896 PyThreadState* __tstate = wxPyBeginAllowThreads();
46897 result = (bool)(arg1)->IsShown();
46898 wxPyEndAllowThreads(__tstate);
46899 if (PyErr_Occurred()) SWIG_fail;
46900 }
46901 {
46902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46903 }
46904 return resultobj;
46905 fail:
46906 return NULL;
46907 }
46908
46909
46910 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46911 PyObject *resultobj = 0;
46912 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46913 wxPoint result;
46914 void *argp1 = 0 ;
46915 int res1 = 0 ;
46916 PyObject *swig_obj[1] ;
46917
46918 if (!args) SWIG_fail;
46919 swig_obj[0] = args;
46920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46921 if (!SWIG_IsOK(res1)) {
46922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46923 }
46924 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46925 {
46926 PyThreadState* __tstate = wxPyBeginAllowThreads();
46927 result = (arg1)->GetPosition();
46928 wxPyEndAllowThreads(__tstate);
46929 if (PyErr_Occurred()) SWIG_fail;
46930 }
46931 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46932 return resultobj;
46933 fail:
46934 return NULL;
46935 }
46936
46937
46938 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46939 PyObject *resultobj = 0;
46940 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46941 PyObject *result = 0 ;
46942 void *argp1 = 0 ;
46943 int res1 = 0 ;
46944 PyObject *swig_obj[1] ;
46945
46946 if (!args) SWIG_fail;
46947 swig_obj[0] = args;
46948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46949 if (!SWIG_IsOK(res1)) {
46950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46951 }
46952 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46953 {
46954 PyThreadState* __tstate = wxPyBeginAllowThreads();
46955 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46956 wxPyEndAllowThreads(__tstate);
46957 if (PyErr_Occurred()) SWIG_fail;
46958 }
46959 resultobj = result;
46960 return resultobj;
46961 fail:
46962 return NULL;
46963 }
46964
46965
46966 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46967 PyObject *resultobj = 0;
46968 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46969 PyObject *arg2 = (PyObject *) 0 ;
46970 void *argp1 = 0 ;
46971 int res1 = 0 ;
46972 PyObject * obj0 = 0 ;
46973 PyObject * obj1 = 0 ;
46974 char * kwnames[] = {
46975 (char *) "self",(char *) "userData", NULL
46976 };
46977
46978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46980 if (!SWIG_IsOK(res1)) {
46981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46982 }
46983 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46984 arg2 = obj1;
46985 {
46986 PyThreadState* __tstate = wxPyBeginAllowThreads();
46987 wxSizerItem_SetUserData(arg1,arg2);
46988 wxPyEndAllowThreads(__tstate);
46989 if (PyErr_Occurred()) SWIG_fail;
46990 }
46991 resultobj = SWIG_Py_Void();
46992 return resultobj;
46993 fail:
46994 return NULL;
46995 }
46996
46997
46998 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46999 PyObject *obj;
47000 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47001 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47002 return SWIG_Py_Void();
47003 }
47004
47005 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47006 return SWIG_Python_InitShadowInstance(args);
47007 }
47008
47009 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47010 PyObject *resultobj = 0;
47011 wxSizer *arg1 = (wxSizer *) 0 ;
47012 void *argp1 = 0 ;
47013 int res1 = 0 ;
47014 PyObject *swig_obj[1] ;
47015
47016 if (!args) SWIG_fail;
47017 swig_obj[0] = args;
47018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47019 if (!SWIG_IsOK(res1)) {
47020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47021 }
47022 arg1 = reinterpret_cast< wxSizer * >(argp1);
47023 {
47024 PyThreadState* __tstate = wxPyBeginAllowThreads();
47025 delete arg1;
47026
47027 wxPyEndAllowThreads(__tstate);
47028 if (PyErr_Occurred()) SWIG_fail;
47029 }
47030 resultobj = SWIG_Py_Void();
47031 return resultobj;
47032 fail:
47033 return NULL;
47034 }
47035
47036
47037 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47038 PyObject *resultobj = 0;
47039 wxSizer *arg1 = (wxSizer *) 0 ;
47040 PyObject *arg2 = (PyObject *) 0 ;
47041 void *argp1 = 0 ;
47042 int res1 = 0 ;
47043 PyObject * obj0 = 0 ;
47044 PyObject * obj1 = 0 ;
47045 char * kwnames[] = {
47046 (char *) "self",(char *) "_self", NULL
47047 };
47048
47049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47051 if (!SWIG_IsOK(res1)) {
47052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47053 }
47054 arg1 = reinterpret_cast< wxSizer * >(argp1);
47055 arg2 = obj1;
47056 {
47057 PyThreadState* __tstate = wxPyBeginAllowThreads();
47058 wxSizer__setOORInfo(arg1,arg2);
47059 wxPyEndAllowThreads(__tstate);
47060 if (PyErr_Occurred()) SWIG_fail;
47061 }
47062 resultobj = SWIG_Py_Void();
47063 return resultobj;
47064 fail:
47065 return NULL;
47066 }
47067
47068
47069 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47070 PyObject *resultobj = 0;
47071 wxSizer *arg1 = (wxSizer *) 0 ;
47072 PyObject *arg2 = (PyObject *) 0 ;
47073 int arg3 = (int) 0 ;
47074 int arg4 = (int) 0 ;
47075 int arg5 = (int) 0 ;
47076 PyObject *arg6 = (PyObject *) NULL ;
47077 wxSizerItem *result = 0 ;
47078 void *argp1 = 0 ;
47079 int res1 = 0 ;
47080 int val3 ;
47081 int ecode3 = 0 ;
47082 int val4 ;
47083 int ecode4 = 0 ;
47084 int val5 ;
47085 int ecode5 = 0 ;
47086 PyObject * obj0 = 0 ;
47087 PyObject * obj1 = 0 ;
47088 PyObject * obj2 = 0 ;
47089 PyObject * obj3 = 0 ;
47090 PyObject * obj4 = 0 ;
47091 PyObject * obj5 = 0 ;
47092 char * kwnames[] = {
47093 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47094 };
47095
47096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47098 if (!SWIG_IsOK(res1)) {
47099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47100 }
47101 arg1 = reinterpret_cast< wxSizer * >(argp1);
47102 arg2 = obj1;
47103 if (obj2) {
47104 ecode3 = SWIG_AsVal_int(obj2, &val3);
47105 if (!SWIG_IsOK(ecode3)) {
47106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47107 }
47108 arg3 = static_cast< int >(val3);
47109 }
47110 if (obj3) {
47111 ecode4 = SWIG_AsVal_int(obj3, &val4);
47112 if (!SWIG_IsOK(ecode4)) {
47113 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47114 }
47115 arg4 = static_cast< int >(val4);
47116 }
47117 if (obj4) {
47118 ecode5 = SWIG_AsVal_int(obj4, &val5);
47119 if (!SWIG_IsOK(ecode5)) {
47120 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47121 }
47122 arg5 = static_cast< int >(val5);
47123 }
47124 if (obj5) {
47125 arg6 = obj5;
47126 }
47127 {
47128 PyThreadState* __tstate = wxPyBeginAllowThreads();
47129 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47130 wxPyEndAllowThreads(__tstate);
47131 if (PyErr_Occurred()) SWIG_fail;
47132 }
47133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47134 return resultobj;
47135 fail:
47136 return NULL;
47137 }
47138
47139
47140 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47141 PyObject *resultobj = 0;
47142 wxSizer *arg1 = (wxSizer *) 0 ;
47143 int arg2 ;
47144 PyObject *arg3 = (PyObject *) 0 ;
47145 int arg4 = (int) 0 ;
47146 int arg5 = (int) 0 ;
47147 int arg6 = (int) 0 ;
47148 PyObject *arg7 = (PyObject *) NULL ;
47149 wxSizerItem *result = 0 ;
47150 void *argp1 = 0 ;
47151 int res1 = 0 ;
47152 int val2 ;
47153 int ecode2 = 0 ;
47154 int val4 ;
47155 int ecode4 = 0 ;
47156 int val5 ;
47157 int ecode5 = 0 ;
47158 int val6 ;
47159 int ecode6 = 0 ;
47160 PyObject * obj0 = 0 ;
47161 PyObject * obj1 = 0 ;
47162 PyObject * obj2 = 0 ;
47163 PyObject * obj3 = 0 ;
47164 PyObject * obj4 = 0 ;
47165 PyObject * obj5 = 0 ;
47166 PyObject * obj6 = 0 ;
47167 char * kwnames[] = {
47168 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47169 };
47170
47171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47173 if (!SWIG_IsOK(res1)) {
47174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47175 }
47176 arg1 = reinterpret_cast< wxSizer * >(argp1);
47177 ecode2 = SWIG_AsVal_int(obj1, &val2);
47178 if (!SWIG_IsOK(ecode2)) {
47179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47180 }
47181 arg2 = static_cast< int >(val2);
47182 arg3 = obj2;
47183 if (obj3) {
47184 ecode4 = SWIG_AsVal_int(obj3, &val4);
47185 if (!SWIG_IsOK(ecode4)) {
47186 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47187 }
47188 arg4 = static_cast< int >(val4);
47189 }
47190 if (obj4) {
47191 ecode5 = SWIG_AsVal_int(obj4, &val5);
47192 if (!SWIG_IsOK(ecode5)) {
47193 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47194 }
47195 arg5 = static_cast< int >(val5);
47196 }
47197 if (obj5) {
47198 ecode6 = SWIG_AsVal_int(obj5, &val6);
47199 if (!SWIG_IsOK(ecode6)) {
47200 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47201 }
47202 arg6 = static_cast< int >(val6);
47203 }
47204 if (obj6) {
47205 arg7 = obj6;
47206 }
47207 {
47208 PyThreadState* __tstate = wxPyBeginAllowThreads();
47209 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47210 wxPyEndAllowThreads(__tstate);
47211 if (PyErr_Occurred()) SWIG_fail;
47212 }
47213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47214 return resultobj;
47215 fail:
47216 return NULL;
47217 }
47218
47219
47220 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47221 PyObject *resultobj = 0;
47222 wxSizer *arg1 = (wxSizer *) 0 ;
47223 PyObject *arg2 = (PyObject *) 0 ;
47224 int arg3 = (int) 0 ;
47225 int arg4 = (int) 0 ;
47226 int arg5 = (int) 0 ;
47227 PyObject *arg6 = (PyObject *) NULL ;
47228 wxSizerItem *result = 0 ;
47229 void *argp1 = 0 ;
47230 int res1 = 0 ;
47231 int val3 ;
47232 int ecode3 = 0 ;
47233 int val4 ;
47234 int ecode4 = 0 ;
47235 int val5 ;
47236 int ecode5 = 0 ;
47237 PyObject * obj0 = 0 ;
47238 PyObject * obj1 = 0 ;
47239 PyObject * obj2 = 0 ;
47240 PyObject * obj3 = 0 ;
47241 PyObject * obj4 = 0 ;
47242 PyObject * obj5 = 0 ;
47243 char * kwnames[] = {
47244 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47245 };
47246
47247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47249 if (!SWIG_IsOK(res1)) {
47250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47251 }
47252 arg1 = reinterpret_cast< wxSizer * >(argp1);
47253 arg2 = obj1;
47254 if (obj2) {
47255 ecode3 = SWIG_AsVal_int(obj2, &val3);
47256 if (!SWIG_IsOK(ecode3)) {
47257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47258 }
47259 arg3 = static_cast< int >(val3);
47260 }
47261 if (obj3) {
47262 ecode4 = SWIG_AsVal_int(obj3, &val4);
47263 if (!SWIG_IsOK(ecode4)) {
47264 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47265 }
47266 arg4 = static_cast< int >(val4);
47267 }
47268 if (obj4) {
47269 ecode5 = SWIG_AsVal_int(obj4, &val5);
47270 if (!SWIG_IsOK(ecode5)) {
47271 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47272 }
47273 arg5 = static_cast< int >(val5);
47274 }
47275 if (obj5) {
47276 arg6 = obj5;
47277 }
47278 {
47279 PyThreadState* __tstate = wxPyBeginAllowThreads();
47280 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47281 wxPyEndAllowThreads(__tstate);
47282 if (PyErr_Occurred()) SWIG_fail;
47283 }
47284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47285 return resultobj;
47286 fail:
47287 return NULL;
47288 }
47289
47290
47291 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47292 PyObject *resultobj = 0;
47293 wxSizer *arg1 = (wxSizer *) 0 ;
47294 PyObject *arg2 = (PyObject *) 0 ;
47295 bool result;
47296 void *argp1 = 0 ;
47297 int res1 = 0 ;
47298 PyObject * obj0 = 0 ;
47299 PyObject * obj1 = 0 ;
47300 char * kwnames[] = {
47301 (char *) "self",(char *) "item", NULL
47302 };
47303
47304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47306 if (!SWIG_IsOK(res1)) {
47307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47308 }
47309 arg1 = reinterpret_cast< wxSizer * >(argp1);
47310 arg2 = obj1;
47311 {
47312 PyThreadState* __tstate = wxPyBeginAllowThreads();
47313 result = (bool)wxSizer_Remove(arg1,arg2);
47314 wxPyEndAllowThreads(__tstate);
47315 if (PyErr_Occurred()) SWIG_fail;
47316 }
47317 {
47318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47319 }
47320 return resultobj;
47321 fail:
47322 return NULL;
47323 }
47324
47325
47326 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47327 PyObject *resultobj = 0;
47328 wxSizer *arg1 = (wxSizer *) 0 ;
47329 PyObject *arg2 = (PyObject *) 0 ;
47330 bool result;
47331 void *argp1 = 0 ;
47332 int res1 = 0 ;
47333 PyObject * obj0 = 0 ;
47334 PyObject * obj1 = 0 ;
47335 char * kwnames[] = {
47336 (char *) "self",(char *) "item", NULL
47337 };
47338
47339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47341 if (!SWIG_IsOK(res1)) {
47342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47343 }
47344 arg1 = reinterpret_cast< wxSizer * >(argp1);
47345 arg2 = obj1;
47346 {
47347 PyThreadState* __tstate = wxPyBeginAllowThreads();
47348 result = (bool)wxSizer_Detach(arg1,arg2);
47349 wxPyEndAllowThreads(__tstate);
47350 if (PyErr_Occurred()) SWIG_fail;
47351 }
47352 {
47353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47354 }
47355 return resultobj;
47356 fail:
47357 return NULL;
47358 }
47359
47360
47361 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47362 PyObject *resultobj = 0;
47363 wxSizer *arg1 = (wxSizer *) 0 ;
47364 PyObject *arg2 = (PyObject *) 0 ;
47365 wxSizerItem *result = 0 ;
47366 void *argp1 = 0 ;
47367 int res1 = 0 ;
47368 PyObject * obj0 = 0 ;
47369 PyObject * obj1 = 0 ;
47370 char * kwnames[] = {
47371 (char *) "self",(char *) "item", NULL
47372 };
47373
47374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47376 if (!SWIG_IsOK(res1)) {
47377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47378 }
47379 arg1 = reinterpret_cast< wxSizer * >(argp1);
47380 arg2 = obj1;
47381 {
47382 PyThreadState* __tstate = wxPyBeginAllowThreads();
47383 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47384 wxPyEndAllowThreads(__tstate);
47385 if (PyErr_Occurred()) SWIG_fail;
47386 }
47387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47388 return resultobj;
47389 fail:
47390 return NULL;
47391 }
47392
47393
47394 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47395 PyObject *resultobj = 0;
47396 wxSizer *arg1 = (wxSizer *) 0 ;
47397 PyObject *arg2 = (PyObject *) 0 ;
47398 wxSize *arg3 = 0 ;
47399 void *argp1 = 0 ;
47400 int res1 = 0 ;
47401 wxSize temp3 ;
47402 PyObject * obj0 = 0 ;
47403 PyObject * obj1 = 0 ;
47404 PyObject * obj2 = 0 ;
47405 char * kwnames[] = {
47406 (char *) "self",(char *) "item",(char *) "size", NULL
47407 };
47408
47409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47411 if (!SWIG_IsOK(res1)) {
47412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47413 }
47414 arg1 = reinterpret_cast< wxSizer * >(argp1);
47415 arg2 = obj1;
47416 {
47417 arg3 = &temp3;
47418 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47419 }
47420 {
47421 PyThreadState* __tstate = wxPyBeginAllowThreads();
47422 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47423 wxPyEndAllowThreads(__tstate);
47424 if (PyErr_Occurred()) SWIG_fail;
47425 }
47426 resultobj = SWIG_Py_Void();
47427 return resultobj;
47428 fail:
47429 return NULL;
47430 }
47431
47432
47433 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47434 PyObject *resultobj = 0;
47435 wxSizer *arg1 = (wxSizer *) 0 ;
47436 wxWindow *arg2 = (wxWindow *) 0 ;
47437 wxWindow *arg3 = (wxWindow *) 0 ;
47438 bool arg4 = (bool) false ;
47439 bool result;
47440 void *argp1 = 0 ;
47441 int res1 = 0 ;
47442 void *argp2 = 0 ;
47443 int res2 = 0 ;
47444 void *argp3 = 0 ;
47445 int res3 = 0 ;
47446 bool val4 ;
47447 int ecode4 = 0 ;
47448 PyObject * obj0 = 0 ;
47449 PyObject * obj1 = 0 ;
47450 PyObject * obj2 = 0 ;
47451 PyObject * obj3 = 0 ;
47452 char * kwnames[] = {
47453 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
47454 };
47455
47456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47458 if (!SWIG_IsOK(res1)) {
47459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
47460 }
47461 arg1 = reinterpret_cast< wxSizer * >(argp1);
47462 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47463 if (!SWIG_IsOK(res2)) {
47464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
47465 }
47466 arg2 = reinterpret_cast< wxWindow * >(argp2);
47467 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
47468 if (!SWIG_IsOK(res3)) {
47469 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
47470 }
47471 arg3 = reinterpret_cast< wxWindow * >(argp3);
47472 if (obj3) {
47473 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47474 if (!SWIG_IsOK(ecode4)) {
47475 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
47476 }
47477 arg4 = static_cast< bool >(val4);
47478 }
47479 {
47480 PyThreadState* __tstate = wxPyBeginAllowThreads();
47481 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47482 wxPyEndAllowThreads(__tstate);
47483 if (PyErr_Occurred()) SWIG_fail;
47484 }
47485 {
47486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47487 }
47488 return resultobj;
47489 fail:
47490 return NULL;
47491 }
47492
47493
47494 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47495 PyObject *resultobj = 0;
47496 wxSizer *arg1 = (wxSizer *) 0 ;
47497 wxSizer *arg2 = (wxSizer *) 0 ;
47498 wxSizer *arg3 = (wxSizer *) 0 ;
47499 bool arg4 = (bool) false ;
47500 bool result;
47501 void *argp1 = 0 ;
47502 int res1 = 0 ;
47503 void *argp2 = 0 ;
47504 int res2 = 0 ;
47505 void *argp3 = 0 ;
47506 int res3 = 0 ;
47507 bool val4 ;
47508 int ecode4 = 0 ;
47509 PyObject * obj0 = 0 ;
47510 PyObject * obj1 = 0 ;
47511 PyObject * obj2 = 0 ;
47512 PyObject * obj3 = 0 ;
47513 char * kwnames[] = {
47514 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
47515 };
47516
47517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47519 if (!SWIG_IsOK(res1)) {
47520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47521 }
47522 arg1 = reinterpret_cast< wxSizer * >(argp1);
47523 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
47524 if (!SWIG_IsOK(res2)) {
47525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47526 }
47527 arg2 = reinterpret_cast< wxSizer * >(argp2);
47528 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
47529 if (!SWIG_IsOK(res3)) {
47530 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
47531 }
47532 arg3 = reinterpret_cast< wxSizer * >(argp3);
47533 if (obj3) {
47534 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47535 if (!SWIG_IsOK(ecode4)) {
47536 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
47537 }
47538 arg4 = static_cast< bool >(val4);
47539 }
47540 {
47541 PyThreadState* __tstate = wxPyBeginAllowThreads();
47542 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47543 wxPyEndAllowThreads(__tstate);
47544 if (PyErr_Occurred()) SWIG_fail;
47545 }
47546 {
47547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47548 }
47549 return resultobj;
47550 fail:
47551 return NULL;
47552 }
47553
47554
47555 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47556 PyObject *resultobj = 0;
47557 wxSizer *arg1 = (wxSizer *) 0 ;
47558 size_t arg2 ;
47559 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47560 bool result;
47561 void *argp1 = 0 ;
47562 int res1 = 0 ;
47563 size_t val2 ;
47564 int ecode2 = 0 ;
47565 void *argp3 = 0 ;
47566 int res3 = 0 ;
47567 PyObject * obj0 = 0 ;
47568 PyObject * obj1 = 0 ;
47569 PyObject * obj2 = 0 ;
47570 char * kwnames[] = {
47571 (char *) "self",(char *) "index",(char *) "newitem", NULL
47572 };
47573
47574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47576 if (!SWIG_IsOK(res1)) {
47577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47578 }
47579 arg1 = reinterpret_cast< wxSizer * >(argp1);
47580 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47581 if (!SWIG_IsOK(ecode2)) {
47582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
47583 }
47584 arg2 = static_cast< size_t >(val2);
47585 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47586 if (!SWIG_IsOK(res3)) {
47587 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47588 }
47589 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
47590 {
47591 PyThreadState* __tstate = wxPyBeginAllowThreads();
47592 result = (bool)(arg1)->Replace(arg2,arg3);
47593 wxPyEndAllowThreads(__tstate);
47594 if (PyErr_Occurred()) SWIG_fail;
47595 }
47596 {
47597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47598 }
47599 return resultobj;
47600 fail:
47601 return NULL;
47602 }
47603
47604
47605 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47606 PyObject *resultobj = 0;
47607 wxSizer *arg1 = (wxSizer *) 0 ;
47608 wxWindow *arg2 = (wxWindow *) 0 ;
47609 void *argp1 = 0 ;
47610 int res1 = 0 ;
47611 void *argp2 = 0 ;
47612 int res2 = 0 ;
47613 PyObject * obj0 = 0 ;
47614 PyObject * obj1 = 0 ;
47615 char * kwnames[] = {
47616 (char *) "self",(char *) "window", NULL
47617 };
47618
47619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47621 if (!SWIG_IsOK(res1)) {
47622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
47623 }
47624 arg1 = reinterpret_cast< wxSizer * >(argp1);
47625 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47626 if (!SWIG_IsOK(res2)) {
47627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47628 }
47629 arg2 = reinterpret_cast< wxWindow * >(argp2);
47630 {
47631 PyThreadState* __tstate = wxPyBeginAllowThreads();
47632 (arg1)->SetContainingWindow(arg2);
47633 wxPyEndAllowThreads(__tstate);
47634 if (PyErr_Occurred()) SWIG_fail;
47635 }
47636 resultobj = SWIG_Py_Void();
47637 return resultobj;
47638 fail:
47639 return NULL;
47640 }
47641
47642
47643 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47644 PyObject *resultobj = 0;
47645 wxSizer *arg1 = (wxSizer *) 0 ;
47646 wxWindow *result = 0 ;
47647 void *argp1 = 0 ;
47648 int res1 = 0 ;
47649 PyObject *swig_obj[1] ;
47650
47651 if (!args) SWIG_fail;
47652 swig_obj[0] = args;
47653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47654 if (!SWIG_IsOK(res1)) {
47655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
47656 }
47657 arg1 = reinterpret_cast< wxSizer * >(argp1);
47658 {
47659 PyThreadState* __tstate = wxPyBeginAllowThreads();
47660 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
47661 wxPyEndAllowThreads(__tstate);
47662 if (PyErr_Occurred()) SWIG_fail;
47663 }
47664 {
47665 resultobj = wxPyMake_wxObject(result, 0);
47666 }
47667 return resultobj;
47668 fail:
47669 return NULL;
47670 }
47671
47672
47673 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47674 PyObject *resultobj = 0;
47675 wxSizer *arg1 = (wxSizer *) 0 ;
47676 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47677 wxSizerItem *result = 0 ;
47678 void *argp1 = 0 ;
47679 int res1 = 0 ;
47680 int res2 = 0 ;
47681 PyObject * obj0 = 0 ;
47682 PyObject * obj1 = 0 ;
47683 char * kwnames[] = {
47684 (char *) "self",(char *) "item", NULL
47685 };
47686
47687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47689 if (!SWIG_IsOK(res1)) {
47690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47691 }
47692 arg1 = reinterpret_cast< wxSizer * >(argp1);
47693 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47694 if (!SWIG_IsOK(res2)) {
47695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47696 }
47697 {
47698 PyThreadState* __tstate = wxPyBeginAllowThreads();
47699 result = (wxSizerItem *)(arg1)->Add(arg2);
47700 wxPyEndAllowThreads(__tstate);
47701 if (PyErr_Occurred()) SWIG_fail;
47702 }
47703 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47704 return resultobj;
47705 fail:
47706 return NULL;
47707 }
47708
47709
47710 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47711 PyObject *resultobj = 0;
47712 wxSizer *arg1 = (wxSizer *) 0 ;
47713 size_t arg2 ;
47714 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47715 wxSizerItem *result = 0 ;
47716 void *argp1 = 0 ;
47717 int res1 = 0 ;
47718 size_t val2 ;
47719 int ecode2 = 0 ;
47720 int res3 = 0 ;
47721 PyObject * obj0 = 0 ;
47722 PyObject * obj1 = 0 ;
47723 PyObject * obj2 = 0 ;
47724 char * kwnames[] = {
47725 (char *) "self",(char *) "index",(char *) "item", NULL
47726 };
47727
47728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47730 if (!SWIG_IsOK(res1)) {
47731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47732 }
47733 arg1 = reinterpret_cast< wxSizer * >(argp1);
47734 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47735 if (!SWIG_IsOK(ecode2)) {
47736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47737 }
47738 arg2 = static_cast< size_t >(val2);
47739 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47740 if (!SWIG_IsOK(res3)) {
47741 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47742 }
47743 {
47744 PyThreadState* __tstate = wxPyBeginAllowThreads();
47745 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47746 wxPyEndAllowThreads(__tstate);
47747 if (PyErr_Occurred()) SWIG_fail;
47748 }
47749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47750 return resultobj;
47751 fail:
47752 return NULL;
47753 }
47754
47755
47756 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47757 PyObject *resultobj = 0;
47758 wxSizer *arg1 = (wxSizer *) 0 ;
47759 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47760 wxSizerItem *result = 0 ;
47761 void *argp1 = 0 ;
47762 int res1 = 0 ;
47763 int res2 = 0 ;
47764 PyObject * obj0 = 0 ;
47765 PyObject * obj1 = 0 ;
47766 char * kwnames[] = {
47767 (char *) "self",(char *) "item", NULL
47768 };
47769
47770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47772 if (!SWIG_IsOK(res1)) {
47773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47774 }
47775 arg1 = reinterpret_cast< wxSizer * >(argp1);
47776 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47777 if (!SWIG_IsOK(res2)) {
47778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47779 }
47780 {
47781 PyThreadState* __tstate = wxPyBeginAllowThreads();
47782 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47783 wxPyEndAllowThreads(__tstate);
47784 if (PyErr_Occurred()) SWIG_fail;
47785 }
47786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47787 return resultobj;
47788 fail:
47789 return NULL;
47790 }
47791
47792
47793 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47794 PyObject *resultobj = 0;
47795 wxSizer *arg1 = (wxSizer *) 0 ;
47796 int arg2 ;
47797 int arg3 ;
47798 int arg4 ;
47799 int arg5 ;
47800 void *argp1 = 0 ;
47801 int res1 = 0 ;
47802 int val2 ;
47803 int ecode2 = 0 ;
47804 int val3 ;
47805 int ecode3 = 0 ;
47806 int val4 ;
47807 int ecode4 = 0 ;
47808 int val5 ;
47809 int ecode5 = 0 ;
47810 PyObject * obj0 = 0 ;
47811 PyObject * obj1 = 0 ;
47812 PyObject * obj2 = 0 ;
47813 PyObject * obj3 = 0 ;
47814 PyObject * obj4 = 0 ;
47815 char * kwnames[] = {
47816 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47817 };
47818
47819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47821 if (!SWIG_IsOK(res1)) {
47822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47823 }
47824 arg1 = reinterpret_cast< wxSizer * >(argp1);
47825 ecode2 = SWIG_AsVal_int(obj1, &val2);
47826 if (!SWIG_IsOK(ecode2)) {
47827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47828 }
47829 arg2 = static_cast< int >(val2);
47830 ecode3 = SWIG_AsVal_int(obj2, &val3);
47831 if (!SWIG_IsOK(ecode3)) {
47832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47833 }
47834 arg3 = static_cast< int >(val3);
47835 ecode4 = SWIG_AsVal_int(obj3, &val4);
47836 if (!SWIG_IsOK(ecode4)) {
47837 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47838 }
47839 arg4 = static_cast< int >(val4);
47840 ecode5 = SWIG_AsVal_int(obj4, &val5);
47841 if (!SWIG_IsOK(ecode5)) {
47842 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47843 }
47844 arg5 = static_cast< int >(val5);
47845 {
47846 PyThreadState* __tstate = wxPyBeginAllowThreads();
47847 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47848 wxPyEndAllowThreads(__tstate);
47849 if (PyErr_Occurred()) SWIG_fail;
47850 }
47851 resultobj = SWIG_Py_Void();
47852 return resultobj;
47853 fail:
47854 return NULL;
47855 }
47856
47857
47858 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47859 PyObject *resultobj = 0;
47860 wxSizer *arg1 = (wxSizer *) 0 ;
47861 wxSize *arg2 = 0 ;
47862 void *argp1 = 0 ;
47863 int res1 = 0 ;
47864 wxSize temp2 ;
47865 PyObject * obj0 = 0 ;
47866 PyObject * obj1 = 0 ;
47867 char * kwnames[] = {
47868 (char *) "self",(char *) "size", NULL
47869 };
47870
47871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47873 if (!SWIG_IsOK(res1)) {
47874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47875 }
47876 arg1 = reinterpret_cast< wxSizer * >(argp1);
47877 {
47878 arg2 = &temp2;
47879 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47880 }
47881 {
47882 PyThreadState* __tstate = wxPyBeginAllowThreads();
47883 (arg1)->SetMinSize((wxSize const &)*arg2);
47884 wxPyEndAllowThreads(__tstate);
47885 if (PyErr_Occurred()) SWIG_fail;
47886 }
47887 resultobj = SWIG_Py_Void();
47888 return resultobj;
47889 fail:
47890 return NULL;
47891 }
47892
47893
47894 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47895 PyObject *resultobj = 0;
47896 wxSizer *arg1 = (wxSizer *) 0 ;
47897 wxSize result;
47898 void *argp1 = 0 ;
47899 int res1 = 0 ;
47900 PyObject *swig_obj[1] ;
47901
47902 if (!args) SWIG_fail;
47903 swig_obj[0] = args;
47904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47905 if (!SWIG_IsOK(res1)) {
47906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47907 }
47908 arg1 = reinterpret_cast< wxSizer * >(argp1);
47909 {
47910 PyThreadState* __tstate = wxPyBeginAllowThreads();
47911 result = (arg1)->GetSize();
47912 wxPyEndAllowThreads(__tstate);
47913 if (PyErr_Occurred()) SWIG_fail;
47914 }
47915 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47916 return resultobj;
47917 fail:
47918 return NULL;
47919 }
47920
47921
47922 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47923 PyObject *resultobj = 0;
47924 wxSizer *arg1 = (wxSizer *) 0 ;
47925 wxPoint result;
47926 void *argp1 = 0 ;
47927 int res1 = 0 ;
47928 PyObject *swig_obj[1] ;
47929
47930 if (!args) SWIG_fail;
47931 swig_obj[0] = args;
47932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47933 if (!SWIG_IsOK(res1)) {
47934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47935 }
47936 arg1 = reinterpret_cast< wxSizer * >(argp1);
47937 {
47938 PyThreadState* __tstate = wxPyBeginAllowThreads();
47939 result = (arg1)->GetPosition();
47940 wxPyEndAllowThreads(__tstate);
47941 if (PyErr_Occurred()) SWIG_fail;
47942 }
47943 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47944 return resultobj;
47945 fail:
47946 return NULL;
47947 }
47948
47949
47950 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47951 PyObject *resultobj = 0;
47952 wxSizer *arg1 = (wxSizer *) 0 ;
47953 wxSize result;
47954 void *argp1 = 0 ;
47955 int res1 = 0 ;
47956 PyObject *swig_obj[1] ;
47957
47958 if (!args) SWIG_fail;
47959 swig_obj[0] = args;
47960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47961 if (!SWIG_IsOK(res1)) {
47962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47963 }
47964 arg1 = reinterpret_cast< wxSizer * >(argp1);
47965 {
47966 PyThreadState* __tstate = wxPyBeginAllowThreads();
47967 result = (arg1)->GetMinSize();
47968 wxPyEndAllowThreads(__tstate);
47969 if (PyErr_Occurred()) SWIG_fail;
47970 }
47971 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47972 return resultobj;
47973 fail:
47974 return NULL;
47975 }
47976
47977
47978 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47979 PyObject *resultobj = 0;
47980 wxSizer *arg1 = (wxSizer *) 0 ;
47981 void *argp1 = 0 ;
47982 int res1 = 0 ;
47983 PyObject *swig_obj[1] ;
47984
47985 if (!args) SWIG_fail;
47986 swig_obj[0] = args;
47987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47988 if (!SWIG_IsOK(res1)) {
47989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47990 }
47991 arg1 = reinterpret_cast< wxSizer * >(argp1);
47992 {
47993 PyThreadState* __tstate = wxPyBeginAllowThreads();
47994 (arg1)->RecalcSizes();
47995 wxPyEndAllowThreads(__tstate);
47996 if (PyErr_Occurred()) SWIG_fail;
47997 }
47998 resultobj = SWIG_Py_Void();
47999 return resultobj;
48000 fail:
48001 return NULL;
48002 }
48003
48004
48005 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48006 PyObject *resultobj = 0;
48007 wxSizer *arg1 = (wxSizer *) 0 ;
48008 wxSize result;
48009 void *argp1 = 0 ;
48010 int res1 = 0 ;
48011 PyObject *swig_obj[1] ;
48012
48013 if (!args) SWIG_fail;
48014 swig_obj[0] = args;
48015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48016 if (!SWIG_IsOK(res1)) {
48017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48018 }
48019 arg1 = reinterpret_cast< wxSizer * >(argp1);
48020 {
48021 PyThreadState* __tstate = wxPyBeginAllowThreads();
48022 result = (arg1)->CalcMin();
48023 wxPyEndAllowThreads(__tstate);
48024 if (PyErr_Occurred()) SWIG_fail;
48025 }
48026 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48027 return resultobj;
48028 fail:
48029 return NULL;
48030 }
48031
48032
48033 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48034 PyObject *resultobj = 0;
48035 wxSizer *arg1 = (wxSizer *) 0 ;
48036 void *argp1 = 0 ;
48037 int res1 = 0 ;
48038 PyObject *swig_obj[1] ;
48039
48040 if (!args) SWIG_fail;
48041 swig_obj[0] = args;
48042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48043 if (!SWIG_IsOK(res1)) {
48044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48045 }
48046 arg1 = reinterpret_cast< wxSizer * >(argp1);
48047 {
48048 PyThreadState* __tstate = wxPyBeginAllowThreads();
48049 (arg1)->Layout();
48050 wxPyEndAllowThreads(__tstate);
48051 if (PyErr_Occurred()) SWIG_fail;
48052 }
48053 resultobj = SWIG_Py_Void();
48054 return resultobj;
48055 fail:
48056 return NULL;
48057 }
48058
48059
48060 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48061 PyObject *resultobj = 0;
48062 wxSizer *arg1 = (wxSizer *) 0 ;
48063 wxWindow *arg2 = (wxWindow *) 0 ;
48064 wxSize result;
48065 void *argp1 = 0 ;
48066 int res1 = 0 ;
48067 void *argp2 = 0 ;
48068 int res2 = 0 ;
48069 PyObject * obj0 = 0 ;
48070 PyObject * obj1 = 0 ;
48071 char * kwnames[] = {
48072 (char *) "self",(char *) "window", NULL
48073 };
48074
48075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48077 if (!SWIG_IsOK(res1)) {
48078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48079 }
48080 arg1 = reinterpret_cast< wxSizer * >(argp1);
48081 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48082 if (!SWIG_IsOK(res2)) {
48083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48084 }
48085 arg2 = reinterpret_cast< wxWindow * >(argp2);
48086 {
48087 PyThreadState* __tstate = wxPyBeginAllowThreads();
48088 result = (arg1)->Fit(arg2);
48089 wxPyEndAllowThreads(__tstate);
48090 if (PyErr_Occurred()) SWIG_fail;
48091 }
48092 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48093 return resultobj;
48094 fail:
48095 return NULL;
48096 }
48097
48098
48099 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48100 PyObject *resultobj = 0;
48101 wxSizer *arg1 = (wxSizer *) 0 ;
48102 wxWindow *arg2 = (wxWindow *) 0 ;
48103 void *argp1 = 0 ;
48104 int res1 = 0 ;
48105 void *argp2 = 0 ;
48106 int res2 = 0 ;
48107 PyObject * obj0 = 0 ;
48108 PyObject * obj1 = 0 ;
48109 char * kwnames[] = {
48110 (char *) "self",(char *) "window", NULL
48111 };
48112
48113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48115 if (!SWIG_IsOK(res1)) {
48116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48117 }
48118 arg1 = reinterpret_cast< wxSizer * >(argp1);
48119 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48120 if (!SWIG_IsOK(res2)) {
48121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48122 }
48123 arg2 = reinterpret_cast< wxWindow * >(argp2);
48124 {
48125 PyThreadState* __tstate = wxPyBeginAllowThreads();
48126 (arg1)->FitInside(arg2);
48127 wxPyEndAllowThreads(__tstate);
48128 if (PyErr_Occurred()) SWIG_fail;
48129 }
48130 resultobj = SWIG_Py_Void();
48131 return resultobj;
48132 fail:
48133 return NULL;
48134 }
48135
48136
48137 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48138 PyObject *resultobj = 0;
48139 wxSizer *arg1 = (wxSizer *) 0 ;
48140 wxWindow *arg2 = (wxWindow *) 0 ;
48141 void *argp1 = 0 ;
48142 int res1 = 0 ;
48143 void *argp2 = 0 ;
48144 int res2 = 0 ;
48145 PyObject * obj0 = 0 ;
48146 PyObject * obj1 = 0 ;
48147 char * kwnames[] = {
48148 (char *) "self",(char *) "window", NULL
48149 };
48150
48151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48153 if (!SWIG_IsOK(res1)) {
48154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48155 }
48156 arg1 = reinterpret_cast< wxSizer * >(argp1);
48157 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48158 if (!SWIG_IsOK(res2)) {
48159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48160 }
48161 arg2 = reinterpret_cast< wxWindow * >(argp2);
48162 {
48163 PyThreadState* __tstate = wxPyBeginAllowThreads();
48164 (arg1)->SetSizeHints(arg2);
48165 wxPyEndAllowThreads(__tstate);
48166 if (PyErr_Occurred()) SWIG_fail;
48167 }
48168 resultobj = SWIG_Py_Void();
48169 return resultobj;
48170 fail:
48171 return NULL;
48172 }
48173
48174
48175 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48176 PyObject *resultobj = 0;
48177 wxSizer *arg1 = (wxSizer *) 0 ;
48178 wxWindow *arg2 = (wxWindow *) 0 ;
48179 void *argp1 = 0 ;
48180 int res1 = 0 ;
48181 void *argp2 = 0 ;
48182 int res2 = 0 ;
48183 PyObject * obj0 = 0 ;
48184 PyObject * obj1 = 0 ;
48185 char * kwnames[] = {
48186 (char *) "self",(char *) "window", NULL
48187 };
48188
48189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48191 if (!SWIG_IsOK(res1)) {
48192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48193 }
48194 arg1 = reinterpret_cast< wxSizer * >(argp1);
48195 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48196 if (!SWIG_IsOK(res2)) {
48197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48198 }
48199 arg2 = reinterpret_cast< wxWindow * >(argp2);
48200 {
48201 PyThreadState* __tstate = wxPyBeginAllowThreads();
48202 (arg1)->SetVirtualSizeHints(arg2);
48203 wxPyEndAllowThreads(__tstate);
48204 if (PyErr_Occurred()) SWIG_fail;
48205 }
48206 resultobj = SWIG_Py_Void();
48207 return resultobj;
48208 fail:
48209 return NULL;
48210 }
48211
48212
48213 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48214 PyObject *resultobj = 0;
48215 wxSizer *arg1 = (wxSizer *) 0 ;
48216 bool arg2 = (bool) false ;
48217 void *argp1 = 0 ;
48218 int res1 = 0 ;
48219 bool val2 ;
48220 int ecode2 = 0 ;
48221 PyObject * obj0 = 0 ;
48222 PyObject * obj1 = 0 ;
48223 char * kwnames[] = {
48224 (char *) "self",(char *) "deleteWindows", NULL
48225 };
48226
48227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48229 if (!SWIG_IsOK(res1)) {
48230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48231 }
48232 arg1 = reinterpret_cast< wxSizer * >(argp1);
48233 if (obj1) {
48234 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48235 if (!SWIG_IsOK(ecode2)) {
48236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48237 }
48238 arg2 = static_cast< bool >(val2);
48239 }
48240 {
48241 PyThreadState* __tstate = wxPyBeginAllowThreads();
48242 (arg1)->Clear(arg2);
48243 wxPyEndAllowThreads(__tstate);
48244 if (PyErr_Occurred()) SWIG_fail;
48245 }
48246 resultobj = SWIG_Py_Void();
48247 return resultobj;
48248 fail:
48249 return NULL;
48250 }
48251
48252
48253 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48254 PyObject *resultobj = 0;
48255 wxSizer *arg1 = (wxSizer *) 0 ;
48256 void *argp1 = 0 ;
48257 int res1 = 0 ;
48258 PyObject *swig_obj[1] ;
48259
48260 if (!args) SWIG_fail;
48261 swig_obj[0] = args;
48262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48263 if (!SWIG_IsOK(res1)) {
48264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48265 }
48266 arg1 = reinterpret_cast< wxSizer * >(argp1);
48267 {
48268 PyThreadState* __tstate = wxPyBeginAllowThreads();
48269 (arg1)->DeleteWindows();
48270 wxPyEndAllowThreads(__tstate);
48271 if (PyErr_Occurred()) SWIG_fail;
48272 }
48273 resultobj = SWIG_Py_Void();
48274 return resultobj;
48275 fail:
48276 return NULL;
48277 }
48278
48279
48280 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48281 PyObject *resultobj = 0;
48282 wxSizer *arg1 = (wxSizer *) 0 ;
48283 PyObject *result = 0 ;
48284 void *argp1 = 0 ;
48285 int res1 = 0 ;
48286 PyObject *swig_obj[1] ;
48287
48288 if (!args) SWIG_fail;
48289 swig_obj[0] = args;
48290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48291 if (!SWIG_IsOK(res1)) {
48292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48293 }
48294 arg1 = reinterpret_cast< wxSizer * >(argp1);
48295 {
48296 PyThreadState* __tstate = wxPyBeginAllowThreads();
48297 result = (PyObject *)wxSizer_GetChildren(arg1);
48298 wxPyEndAllowThreads(__tstate);
48299 if (PyErr_Occurred()) SWIG_fail;
48300 }
48301 resultobj = result;
48302 return resultobj;
48303 fail:
48304 return NULL;
48305 }
48306
48307
48308 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48309 PyObject *resultobj = 0;
48310 wxSizer *arg1 = (wxSizer *) 0 ;
48311 PyObject *arg2 = (PyObject *) 0 ;
48312 bool arg3 = (bool) true ;
48313 bool arg4 = (bool) false ;
48314 bool result;
48315 void *argp1 = 0 ;
48316 int res1 = 0 ;
48317 bool val3 ;
48318 int ecode3 = 0 ;
48319 bool val4 ;
48320 int ecode4 = 0 ;
48321 PyObject * obj0 = 0 ;
48322 PyObject * obj1 = 0 ;
48323 PyObject * obj2 = 0 ;
48324 PyObject * obj3 = 0 ;
48325 char * kwnames[] = {
48326 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48327 };
48328
48329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48331 if (!SWIG_IsOK(res1)) {
48332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48333 }
48334 arg1 = reinterpret_cast< wxSizer * >(argp1);
48335 arg2 = obj1;
48336 if (obj2) {
48337 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48338 if (!SWIG_IsOK(ecode3)) {
48339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48340 }
48341 arg3 = static_cast< bool >(val3);
48342 }
48343 if (obj3) {
48344 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48345 if (!SWIG_IsOK(ecode4)) {
48346 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48347 }
48348 arg4 = static_cast< bool >(val4);
48349 }
48350 {
48351 PyThreadState* __tstate = wxPyBeginAllowThreads();
48352 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48353 wxPyEndAllowThreads(__tstate);
48354 if (PyErr_Occurred()) SWIG_fail;
48355 }
48356 {
48357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48358 }
48359 return resultobj;
48360 fail:
48361 return NULL;
48362 }
48363
48364
48365 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48366 PyObject *resultobj = 0;
48367 wxSizer *arg1 = (wxSizer *) 0 ;
48368 PyObject *arg2 = (PyObject *) 0 ;
48369 bool result;
48370 void *argp1 = 0 ;
48371 int res1 = 0 ;
48372 PyObject * obj0 = 0 ;
48373 PyObject * obj1 = 0 ;
48374 char * kwnames[] = {
48375 (char *) "self",(char *) "item", NULL
48376 };
48377
48378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48380 if (!SWIG_IsOK(res1)) {
48381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48382 }
48383 arg1 = reinterpret_cast< wxSizer * >(argp1);
48384 arg2 = obj1;
48385 {
48386 PyThreadState* __tstate = wxPyBeginAllowThreads();
48387 result = (bool)wxSizer_IsShown(arg1,arg2);
48388 wxPyEndAllowThreads(__tstate);
48389 if (PyErr_Occurred()) SWIG_fail;
48390 }
48391 {
48392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48393 }
48394 return resultobj;
48395 fail:
48396 return NULL;
48397 }
48398
48399
48400 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48401 PyObject *resultobj = 0;
48402 wxSizer *arg1 = (wxSizer *) 0 ;
48403 bool arg2 ;
48404 void *argp1 = 0 ;
48405 int res1 = 0 ;
48406 bool val2 ;
48407 int ecode2 = 0 ;
48408 PyObject * obj0 = 0 ;
48409 PyObject * obj1 = 0 ;
48410 char * kwnames[] = {
48411 (char *) "self",(char *) "show", NULL
48412 };
48413
48414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48416 if (!SWIG_IsOK(res1)) {
48417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48418 }
48419 arg1 = reinterpret_cast< wxSizer * >(argp1);
48420 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48421 if (!SWIG_IsOK(ecode2)) {
48422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48423 }
48424 arg2 = static_cast< bool >(val2);
48425 {
48426 PyThreadState* __tstate = wxPyBeginAllowThreads();
48427 (arg1)->ShowItems(arg2);
48428 wxPyEndAllowThreads(__tstate);
48429 if (PyErr_Occurred()) SWIG_fail;
48430 }
48431 resultobj = SWIG_Py_Void();
48432 return resultobj;
48433 fail:
48434 return NULL;
48435 }
48436
48437
48438 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48439 PyObject *obj;
48440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48441 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
48442 return SWIG_Py_Void();
48443 }
48444
48445 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48446 PyObject *resultobj = 0;
48447 wxPySizer *result = 0 ;
48448
48449 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
48450 {
48451 PyThreadState* __tstate = wxPyBeginAllowThreads();
48452 result = (wxPySizer *)new wxPySizer();
48453 wxPyEndAllowThreads(__tstate);
48454 if (PyErr_Occurred()) SWIG_fail;
48455 }
48456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
48457 return resultobj;
48458 fail:
48459 return NULL;
48460 }
48461
48462
48463 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48464 PyObject *resultobj = 0;
48465 wxPySizer *arg1 = (wxPySizer *) 0 ;
48466 PyObject *arg2 = (PyObject *) 0 ;
48467 PyObject *arg3 = (PyObject *) 0 ;
48468 void *argp1 = 0 ;
48469 int res1 = 0 ;
48470 PyObject * obj0 = 0 ;
48471 PyObject * obj1 = 0 ;
48472 PyObject * obj2 = 0 ;
48473 char * kwnames[] = {
48474 (char *) "self",(char *) "self",(char *) "_class", NULL
48475 };
48476
48477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
48479 if (!SWIG_IsOK(res1)) {
48480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
48481 }
48482 arg1 = reinterpret_cast< wxPySizer * >(argp1);
48483 arg2 = obj1;
48484 arg3 = obj2;
48485 {
48486 PyThreadState* __tstate = wxPyBeginAllowThreads();
48487 (arg1)->_setCallbackInfo(arg2,arg3);
48488 wxPyEndAllowThreads(__tstate);
48489 if (PyErr_Occurred()) SWIG_fail;
48490 }
48491 resultobj = SWIG_Py_Void();
48492 return resultobj;
48493 fail:
48494 return NULL;
48495 }
48496
48497
48498 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48499 PyObject *obj;
48500 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48501 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
48502 return SWIG_Py_Void();
48503 }
48504
48505 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48506 return SWIG_Python_InitShadowInstance(args);
48507 }
48508
48509 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48510 PyObject *resultobj = 0;
48511 int arg1 = (int) wxHORIZONTAL ;
48512 wxBoxSizer *result = 0 ;
48513 int val1 ;
48514 int ecode1 = 0 ;
48515 PyObject * obj0 = 0 ;
48516 char * kwnames[] = {
48517 (char *) "orient", NULL
48518 };
48519
48520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
48521 if (obj0) {
48522 ecode1 = SWIG_AsVal_int(obj0, &val1);
48523 if (!SWIG_IsOK(ecode1)) {
48524 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
48525 }
48526 arg1 = static_cast< int >(val1);
48527 }
48528 {
48529 PyThreadState* __tstate = wxPyBeginAllowThreads();
48530 result = (wxBoxSizer *)new wxBoxSizer(arg1);
48531 wxPyEndAllowThreads(__tstate);
48532 if (PyErr_Occurred()) SWIG_fail;
48533 }
48534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
48535 return resultobj;
48536 fail:
48537 return NULL;
48538 }
48539
48540
48541 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48542 PyObject *resultobj = 0;
48543 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48544 int result;
48545 void *argp1 = 0 ;
48546 int res1 = 0 ;
48547 PyObject *swig_obj[1] ;
48548
48549 if (!args) SWIG_fail;
48550 swig_obj[0] = args;
48551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48552 if (!SWIG_IsOK(res1)) {
48553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48554 }
48555 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48556 {
48557 PyThreadState* __tstate = wxPyBeginAllowThreads();
48558 result = (int)(arg1)->GetOrientation();
48559 wxPyEndAllowThreads(__tstate);
48560 if (PyErr_Occurred()) SWIG_fail;
48561 }
48562 resultobj = SWIG_From_int(static_cast< int >(result));
48563 return resultobj;
48564 fail:
48565 return NULL;
48566 }
48567
48568
48569 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48570 PyObject *resultobj = 0;
48571 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48572 int arg2 ;
48573 void *argp1 = 0 ;
48574 int res1 = 0 ;
48575 int val2 ;
48576 int ecode2 = 0 ;
48577 PyObject * obj0 = 0 ;
48578 PyObject * obj1 = 0 ;
48579 char * kwnames[] = {
48580 (char *) "self",(char *) "orient", NULL
48581 };
48582
48583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
48584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48585 if (!SWIG_IsOK(res1)) {
48586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48587 }
48588 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48589 ecode2 = SWIG_AsVal_int(obj1, &val2);
48590 if (!SWIG_IsOK(ecode2)) {
48591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
48592 }
48593 arg2 = static_cast< int >(val2);
48594 {
48595 PyThreadState* __tstate = wxPyBeginAllowThreads();
48596 (arg1)->SetOrientation(arg2);
48597 wxPyEndAllowThreads(__tstate);
48598 if (PyErr_Occurred()) SWIG_fail;
48599 }
48600 resultobj = SWIG_Py_Void();
48601 return resultobj;
48602 fail:
48603 return NULL;
48604 }
48605
48606
48607 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48608 PyObject *obj;
48609 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48610 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
48611 return SWIG_Py_Void();
48612 }
48613
48614 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48615 return SWIG_Python_InitShadowInstance(args);
48616 }
48617
48618 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48619 PyObject *resultobj = 0;
48620 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
48621 int arg2 = (int) wxHORIZONTAL ;
48622 wxStaticBoxSizer *result = 0 ;
48623 void *argp1 = 0 ;
48624 int res1 = 0 ;
48625 int val2 ;
48626 int ecode2 = 0 ;
48627 PyObject * obj0 = 0 ;
48628 PyObject * obj1 = 0 ;
48629 char * kwnames[] = {
48630 (char *) "box",(char *) "orient", NULL
48631 };
48632
48633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
48634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
48635 if (!SWIG_IsOK(res1)) {
48636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
48637 }
48638 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
48639 if (obj1) {
48640 ecode2 = SWIG_AsVal_int(obj1, &val2);
48641 if (!SWIG_IsOK(ecode2)) {
48642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
48643 }
48644 arg2 = static_cast< int >(val2);
48645 }
48646 {
48647 PyThreadState* __tstate = wxPyBeginAllowThreads();
48648 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
48649 wxPyEndAllowThreads(__tstate);
48650 if (PyErr_Occurred()) SWIG_fail;
48651 }
48652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
48653 return resultobj;
48654 fail:
48655 return NULL;
48656 }
48657
48658
48659 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48660 PyObject *resultobj = 0;
48661 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
48662 wxStaticBox *result = 0 ;
48663 void *argp1 = 0 ;
48664 int res1 = 0 ;
48665 PyObject *swig_obj[1] ;
48666
48667 if (!args) SWIG_fail;
48668 swig_obj[0] = args;
48669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48670 if (!SWIG_IsOK(res1)) {
48671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48672 }
48673 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48674 {
48675 PyThreadState* __tstate = wxPyBeginAllowThreads();
48676 result = (wxStaticBox *)(arg1)->GetStaticBox();
48677 wxPyEndAllowThreads(__tstate);
48678 if (PyErr_Occurred()) SWIG_fail;
48679 }
48680 {
48681 resultobj = wxPyMake_wxObject(result, (bool)0);
48682 }
48683 return resultobj;
48684 fail:
48685 return NULL;
48686 }
48687
48688
48689 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48690 PyObject *obj;
48691 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48692 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48693 return SWIG_Py_Void();
48694 }
48695
48696 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48697 return SWIG_Python_InitShadowInstance(args);
48698 }
48699
48700 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48701 PyObject *resultobj = 0;
48702 int arg1 = (int) 1 ;
48703 int arg2 = (int) 0 ;
48704 int arg3 = (int) 0 ;
48705 int arg4 = (int) 0 ;
48706 wxGridSizer *result = 0 ;
48707 int val1 ;
48708 int ecode1 = 0 ;
48709 int val2 ;
48710 int ecode2 = 0 ;
48711 int val3 ;
48712 int ecode3 = 0 ;
48713 int val4 ;
48714 int ecode4 = 0 ;
48715 PyObject * obj0 = 0 ;
48716 PyObject * obj1 = 0 ;
48717 PyObject * obj2 = 0 ;
48718 PyObject * obj3 = 0 ;
48719 char * kwnames[] = {
48720 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48721 };
48722
48723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48724 if (obj0) {
48725 ecode1 = SWIG_AsVal_int(obj0, &val1);
48726 if (!SWIG_IsOK(ecode1)) {
48727 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48728 }
48729 arg1 = static_cast< int >(val1);
48730 }
48731 if (obj1) {
48732 ecode2 = SWIG_AsVal_int(obj1, &val2);
48733 if (!SWIG_IsOK(ecode2)) {
48734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48735 }
48736 arg2 = static_cast< int >(val2);
48737 }
48738 if (obj2) {
48739 ecode3 = SWIG_AsVal_int(obj2, &val3);
48740 if (!SWIG_IsOK(ecode3)) {
48741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48742 }
48743 arg3 = static_cast< int >(val3);
48744 }
48745 if (obj3) {
48746 ecode4 = SWIG_AsVal_int(obj3, &val4);
48747 if (!SWIG_IsOK(ecode4)) {
48748 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48749 }
48750 arg4 = static_cast< int >(val4);
48751 }
48752 {
48753 PyThreadState* __tstate = wxPyBeginAllowThreads();
48754 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48755 wxPyEndAllowThreads(__tstate);
48756 if (PyErr_Occurred()) SWIG_fail;
48757 }
48758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48759 return resultobj;
48760 fail:
48761 return NULL;
48762 }
48763
48764
48765 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48766 PyObject *resultobj = 0;
48767 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48768 int arg2 ;
48769 void *argp1 = 0 ;
48770 int res1 = 0 ;
48771 int val2 ;
48772 int ecode2 = 0 ;
48773 PyObject * obj0 = 0 ;
48774 PyObject * obj1 = 0 ;
48775 char * kwnames[] = {
48776 (char *) "self",(char *) "cols", NULL
48777 };
48778
48779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48781 if (!SWIG_IsOK(res1)) {
48782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48783 }
48784 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48785 ecode2 = SWIG_AsVal_int(obj1, &val2);
48786 if (!SWIG_IsOK(ecode2)) {
48787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48788 }
48789 arg2 = static_cast< int >(val2);
48790 {
48791 PyThreadState* __tstate = wxPyBeginAllowThreads();
48792 (arg1)->SetCols(arg2);
48793 wxPyEndAllowThreads(__tstate);
48794 if (PyErr_Occurred()) SWIG_fail;
48795 }
48796 resultobj = SWIG_Py_Void();
48797 return resultobj;
48798 fail:
48799 return NULL;
48800 }
48801
48802
48803 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48804 PyObject *resultobj = 0;
48805 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48806 int arg2 ;
48807 void *argp1 = 0 ;
48808 int res1 = 0 ;
48809 int val2 ;
48810 int ecode2 = 0 ;
48811 PyObject * obj0 = 0 ;
48812 PyObject * obj1 = 0 ;
48813 char * kwnames[] = {
48814 (char *) "self",(char *) "rows", NULL
48815 };
48816
48817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48819 if (!SWIG_IsOK(res1)) {
48820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48821 }
48822 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48823 ecode2 = SWIG_AsVal_int(obj1, &val2);
48824 if (!SWIG_IsOK(ecode2)) {
48825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48826 }
48827 arg2 = static_cast< int >(val2);
48828 {
48829 PyThreadState* __tstate = wxPyBeginAllowThreads();
48830 (arg1)->SetRows(arg2);
48831 wxPyEndAllowThreads(__tstate);
48832 if (PyErr_Occurred()) SWIG_fail;
48833 }
48834 resultobj = SWIG_Py_Void();
48835 return resultobj;
48836 fail:
48837 return NULL;
48838 }
48839
48840
48841 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48842 PyObject *resultobj = 0;
48843 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48844 int arg2 ;
48845 void *argp1 = 0 ;
48846 int res1 = 0 ;
48847 int val2 ;
48848 int ecode2 = 0 ;
48849 PyObject * obj0 = 0 ;
48850 PyObject * obj1 = 0 ;
48851 char * kwnames[] = {
48852 (char *) "self",(char *) "gap", NULL
48853 };
48854
48855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48857 if (!SWIG_IsOK(res1)) {
48858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48859 }
48860 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48861 ecode2 = SWIG_AsVal_int(obj1, &val2);
48862 if (!SWIG_IsOK(ecode2)) {
48863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48864 }
48865 arg2 = static_cast< int >(val2);
48866 {
48867 PyThreadState* __tstate = wxPyBeginAllowThreads();
48868 (arg1)->SetVGap(arg2);
48869 wxPyEndAllowThreads(__tstate);
48870 if (PyErr_Occurred()) SWIG_fail;
48871 }
48872 resultobj = SWIG_Py_Void();
48873 return resultobj;
48874 fail:
48875 return NULL;
48876 }
48877
48878
48879 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48880 PyObject *resultobj = 0;
48881 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48882 int arg2 ;
48883 void *argp1 = 0 ;
48884 int res1 = 0 ;
48885 int val2 ;
48886 int ecode2 = 0 ;
48887 PyObject * obj0 = 0 ;
48888 PyObject * obj1 = 0 ;
48889 char * kwnames[] = {
48890 (char *) "self",(char *) "gap", NULL
48891 };
48892
48893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48895 if (!SWIG_IsOK(res1)) {
48896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48897 }
48898 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48899 ecode2 = SWIG_AsVal_int(obj1, &val2);
48900 if (!SWIG_IsOK(ecode2)) {
48901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48902 }
48903 arg2 = static_cast< int >(val2);
48904 {
48905 PyThreadState* __tstate = wxPyBeginAllowThreads();
48906 (arg1)->SetHGap(arg2);
48907 wxPyEndAllowThreads(__tstate);
48908 if (PyErr_Occurred()) SWIG_fail;
48909 }
48910 resultobj = SWIG_Py_Void();
48911 return resultobj;
48912 fail:
48913 return NULL;
48914 }
48915
48916
48917 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48918 PyObject *resultobj = 0;
48919 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48920 int result;
48921 void *argp1 = 0 ;
48922 int res1 = 0 ;
48923 PyObject *swig_obj[1] ;
48924
48925 if (!args) SWIG_fail;
48926 swig_obj[0] = args;
48927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48928 if (!SWIG_IsOK(res1)) {
48929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48930 }
48931 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48932 {
48933 PyThreadState* __tstate = wxPyBeginAllowThreads();
48934 result = (int)(arg1)->GetCols();
48935 wxPyEndAllowThreads(__tstate);
48936 if (PyErr_Occurred()) SWIG_fail;
48937 }
48938 resultobj = SWIG_From_int(static_cast< int >(result));
48939 return resultobj;
48940 fail:
48941 return NULL;
48942 }
48943
48944
48945 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48946 PyObject *resultobj = 0;
48947 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48948 int result;
48949 void *argp1 = 0 ;
48950 int res1 = 0 ;
48951 PyObject *swig_obj[1] ;
48952
48953 if (!args) SWIG_fail;
48954 swig_obj[0] = args;
48955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48956 if (!SWIG_IsOK(res1)) {
48957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48958 }
48959 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48960 {
48961 PyThreadState* __tstate = wxPyBeginAllowThreads();
48962 result = (int)(arg1)->GetRows();
48963 wxPyEndAllowThreads(__tstate);
48964 if (PyErr_Occurred()) SWIG_fail;
48965 }
48966 resultobj = SWIG_From_int(static_cast< int >(result));
48967 return resultobj;
48968 fail:
48969 return NULL;
48970 }
48971
48972
48973 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48974 PyObject *resultobj = 0;
48975 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48976 int result;
48977 void *argp1 = 0 ;
48978 int res1 = 0 ;
48979 PyObject *swig_obj[1] ;
48980
48981 if (!args) SWIG_fail;
48982 swig_obj[0] = args;
48983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48984 if (!SWIG_IsOK(res1)) {
48985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48986 }
48987 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48988 {
48989 PyThreadState* __tstate = wxPyBeginAllowThreads();
48990 result = (int)(arg1)->GetVGap();
48991 wxPyEndAllowThreads(__tstate);
48992 if (PyErr_Occurred()) SWIG_fail;
48993 }
48994 resultobj = SWIG_From_int(static_cast< int >(result));
48995 return resultobj;
48996 fail:
48997 return NULL;
48998 }
48999
49000
49001 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49002 PyObject *resultobj = 0;
49003 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49004 int result;
49005 void *argp1 = 0 ;
49006 int res1 = 0 ;
49007 PyObject *swig_obj[1] ;
49008
49009 if (!args) SWIG_fail;
49010 swig_obj[0] = args;
49011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49012 if (!SWIG_IsOK(res1)) {
49013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49014 }
49015 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49016 {
49017 PyThreadState* __tstate = wxPyBeginAllowThreads();
49018 result = (int)(arg1)->GetHGap();
49019 wxPyEndAllowThreads(__tstate);
49020 if (PyErr_Occurred()) SWIG_fail;
49021 }
49022 resultobj = SWIG_From_int(static_cast< int >(result));
49023 return resultobj;
49024 fail:
49025 return NULL;
49026 }
49027
49028
49029 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49030 PyObject *obj;
49031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49032 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49033 return SWIG_Py_Void();
49034 }
49035
49036 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49037 return SWIG_Python_InitShadowInstance(args);
49038 }
49039
49040 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49041 PyObject *resultobj = 0;
49042 int arg1 = (int) 1 ;
49043 int arg2 = (int) 0 ;
49044 int arg3 = (int) 0 ;
49045 int arg4 = (int) 0 ;
49046 wxFlexGridSizer *result = 0 ;
49047 int val1 ;
49048 int ecode1 = 0 ;
49049 int val2 ;
49050 int ecode2 = 0 ;
49051 int val3 ;
49052 int ecode3 = 0 ;
49053 int val4 ;
49054 int ecode4 = 0 ;
49055 PyObject * obj0 = 0 ;
49056 PyObject * obj1 = 0 ;
49057 PyObject * obj2 = 0 ;
49058 PyObject * obj3 = 0 ;
49059 char * kwnames[] = {
49060 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49061 };
49062
49063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49064 if (obj0) {
49065 ecode1 = SWIG_AsVal_int(obj0, &val1);
49066 if (!SWIG_IsOK(ecode1)) {
49067 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49068 }
49069 arg1 = static_cast< int >(val1);
49070 }
49071 if (obj1) {
49072 ecode2 = SWIG_AsVal_int(obj1, &val2);
49073 if (!SWIG_IsOK(ecode2)) {
49074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49075 }
49076 arg2 = static_cast< int >(val2);
49077 }
49078 if (obj2) {
49079 ecode3 = SWIG_AsVal_int(obj2, &val3);
49080 if (!SWIG_IsOK(ecode3)) {
49081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49082 }
49083 arg3 = static_cast< int >(val3);
49084 }
49085 if (obj3) {
49086 ecode4 = SWIG_AsVal_int(obj3, &val4);
49087 if (!SWIG_IsOK(ecode4)) {
49088 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49089 }
49090 arg4 = static_cast< int >(val4);
49091 }
49092 {
49093 PyThreadState* __tstate = wxPyBeginAllowThreads();
49094 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49095 wxPyEndAllowThreads(__tstate);
49096 if (PyErr_Occurred()) SWIG_fail;
49097 }
49098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49099 return resultobj;
49100 fail:
49101 return NULL;
49102 }
49103
49104
49105 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49106 PyObject *resultobj = 0;
49107 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49108 size_t arg2 ;
49109 int arg3 = (int) 0 ;
49110 void *argp1 = 0 ;
49111 int res1 = 0 ;
49112 size_t val2 ;
49113 int ecode2 = 0 ;
49114 int val3 ;
49115 int ecode3 = 0 ;
49116 PyObject * obj0 = 0 ;
49117 PyObject * obj1 = 0 ;
49118 PyObject * obj2 = 0 ;
49119 char * kwnames[] = {
49120 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49121 };
49122
49123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49125 if (!SWIG_IsOK(res1)) {
49126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49127 }
49128 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49129 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49130 if (!SWIG_IsOK(ecode2)) {
49131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49132 }
49133 arg2 = static_cast< size_t >(val2);
49134 if (obj2) {
49135 ecode3 = SWIG_AsVal_int(obj2, &val3);
49136 if (!SWIG_IsOK(ecode3)) {
49137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49138 }
49139 arg3 = static_cast< int >(val3);
49140 }
49141 {
49142 PyThreadState* __tstate = wxPyBeginAllowThreads();
49143 (arg1)->AddGrowableRow(arg2,arg3);
49144 wxPyEndAllowThreads(__tstate);
49145 if (PyErr_Occurred()) SWIG_fail;
49146 }
49147 resultobj = SWIG_Py_Void();
49148 return resultobj;
49149 fail:
49150 return NULL;
49151 }
49152
49153
49154 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49155 PyObject *resultobj = 0;
49156 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49157 size_t arg2 ;
49158 void *argp1 = 0 ;
49159 int res1 = 0 ;
49160 size_t val2 ;
49161 int ecode2 = 0 ;
49162 PyObject * obj0 = 0 ;
49163 PyObject * obj1 = 0 ;
49164 char * kwnames[] = {
49165 (char *) "self",(char *) "idx", NULL
49166 };
49167
49168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49170 if (!SWIG_IsOK(res1)) {
49171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49172 }
49173 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49174 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49175 if (!SWIG_IsOK(ecode2)) {
49176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49177 }
49178 arg2 = static_cast< size_t >(val2);
49179 {
49180 PyThreadState* __tstate = wxPyBeginAllowThreads();
49181 (arg1)->RemoveGrowableRow(arg2);
49182 wxPyEndAllowThreads(__tstate);
49183 if (PyErr_Occurred()) SWIG_fail;
49184 }
49185 resultobj = SWIG_Py_Void();
49186 return resultobj;
49187 fail:
49188 return NULL;
49189 }
49190
49191
49192 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49193 PyObject *resultobj = 0;
49194 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49195 size_t arg2 ;
49196 int arg3 = (int) 0 ;
49197 void *argp1 = 0 ;
49198 int res1 = 0 ;
49199 size_t val2 ;
49200 int ecode2 = 0 ;
49201 int val3 ;
49202 int ecode3 = 0 ;
49203 PyObject * obj0 = 0 ;
49204 PyObject * obj1 = 0 ;
49205 PyObject * obj2 = 0 ;
49206 char * kwnames[] = {
49207 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49208 };
49209
49210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49212 if (!SWIG_IsOK(res1)) {
49213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49214 }
49215 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49216 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49217 if (!SWIG_IsOK(ecode2)) {
49218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49219 }
49220 arg2 = static_cast< size_t >(val2);
49221 if (obj2) {
49222 ecode3 = SWIG_AsVal_int(obj2, &val3);
49223 if (!SWIG_IsOK(ecode3)) {
49224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49225 }
49226 arg3 = static_cast< int >(val3);
49227 }
49228 {
49229 PyThreadState* __tstate = wxPyBeginAllowThreads();
49230 (arg1)->AddGrowableCol(arg2,arg3);
49231 wxPyEndAllowThreads(__tstate);
49232 if (PyErr_Occurred()) SWIG_fail;
49233 }
49234 resultobj = SWIG_Py_Void();
49235 return resultobj;
49236 fail:
49237 return NULL;
49238 }
49239
49240
49241 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49242 PyObject *resultobj = 0;
49243 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49244 size_t arg2 ;
49245 void *argp1 = 0 ;
49246 int res1 = 0 ;
49247 size_t val2 ;
49248 int ecode2 = 0 ;
49249 PyObject * obj0 = 0 ;
49250 PyObject * obj1 = 0 ;
49251 char * kwnames[] = {
49252 (char *) "self",(char *) "idx", NULL
49253 };
49254
49255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49257 if (!SWIG_IsOK(res1)) {
49258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49259 }
49260 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49261 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49262 if (!SWIG_IsOK(ecode2)) {
49263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49264 }
49265 arg2 = static_cast< size_t >(val2);
49266 {
49267 PyThreadState* __tstate = wxPyBeginAllowThreads();
49268 (arg1)->RemoveGrowableCol(arg2);
49269 wxPyEndAllowThreads(__tstate);
49270 if (PyErr_Occurred()) SWIG_fail;
49271 }
49272 resultobj = SWIG_Py_Void();
49273 return resultobj;
49274 fail:
49275 return NULL;
49276 }
49277
49278
49279 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49280 PyObject *resultobj = 0;
49281 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49282 int arg2 ;
49283 void *argp1 = 0 ;
49284 int res1 = 0 ;
49285 int val2 ;
49286 int ecode2 = 0 ;
49287 PyObject * obj0 = 0 ;
49288 PyObject * obj1 = 0 ;
49289 char * kwnames[] = {
49290 (char *) "self",(char *) "direction", NULL
49291 };
49292
49293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49295 if (!SWIG_IsOK(res1)) {
49296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49297 }
49298 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49299 ecode2 = SWIG_AsVal_int(obj1, &val2);
49300 if (!SWIG_IsOK(ecode2)) {
49301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49302 }
49303 arg2 = static_cast< int >(val2);
49304 {
49305 PyThreadState* __tstate = wxPyBeginAllowThreads();
49306 (arg1)->SetFlexibleDirection(arg2);
49307 wxPyEndAllowThreads(__tstate);
49308 if (PyErr_Occurred()) SWIG_fail;
49309 }
49310 resultobj = SWIG_Py_Void();
49311 return resultobj;
49312 fail:
49313 return NULL;
49314 }
49315
49316
49317 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49318 PyObject *resultobj = 0;
49319 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49320 int result;
49321 void *argp1 = 0 ;
49322 int res1 = 0 ;
49323 PyObject *swig_obj[1] ;
49324
49325 if (!args) SWIG_fail;
49326 swig_obj[0] = args;
49327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49328 if (!SWIG_IsOK(res1)) {
49329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49330 }
49331 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49332 {
49333 PyThreadState* __tstate = wxPyBeginAllowThreads();
49334 result = (int)(arg1)->GetFlexibleDirection();
49335 wxPyEndAllowThreads(__tstate);
49336 if (PyErr_Occurred()) SWIG_fail;
49337 }
49338 resultobj = SWIG_From_int(static_cast< int >(result));
49339 return resultobj;
49340 fail:
49341 return NULL;
49342 }
49343
49344
49345 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49346 PyObject *resultobj = 0;
49347 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49348 wxFlexSizerGrowMode arg2 ;
49349 void *argp1 = 0 ;
49350 int res1 = 0 ;
49351 int val2 ;
49352 int ecode2 = 0 ;
49353 PyObject * obj0 = 0 ;
49354 PyObject * obj1 = 0 ;
49355 char * kwnames[] = {
49356 (char *) "self",(char *) "mode", NULL
49357 };
49358
49359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49361 if (!SWIG_IsOK(res1)) {
49362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49363 }
49364 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49365 ecode2 = SWIG_AsVal_int(obj1, &val2);
49366 if (!SWIG_IsOK(ecode2)) {
49367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49368 }
49369 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49370 {
49371 PyThreadState* __tstate = wxPyBeginAllowThreads();
49372 (arg1)->SetNonFlexibleGrowMode(arg2);
49373 wxPyEndAllowThreads(__tstate);
49374 if (PyErr_Occurred()) SWIG_fail;
49375 }
49376 resultobj = SWIG_Py_Void();
49377 return resultobj;
49378 fail:
49379 return NULL;
49380 }
49381
49382
49383 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49384 PyObject *resultobj = 0;
49385 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49386 wxFlexSizerGrowMode result;
49387 void *argp1 = 0 ;
49388 int res1 = 0 ;
49389 PyObject *swig_obj[1] ;
49390
49391 if (!args) SWIG_fail;
49392 swig_obj[0] = args;
49393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49394 if (!SWIG_IsOK(res1)) {
49395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49396 }
49397 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49398 {
49399 PyThreadState* __tstate = wxPyBeginAllowThreads();
49400 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49401 wxPyEndAllowThreads(__tstate);
49402 if (PyErr_Occurred()) SWIG_fail;
49403 }
49404 resultobj = SWIG_From_int(static_cast< int >(result));
49405 return resultobj;
49406 fail:
49407 return NULL;
49408 }
49409
49410
49411 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49412 PyObject *resultobj = 0;
49413 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49414 wxArrayInt *result = 0 ;
49415 void *argp1 = 0 ;
49416 int res1 = 0 ;
49417 PyObject *swig_obj[1] ;
49418
49419 if (!args) SWIG_fail;
49420 swig_obj[0] = args;
49421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49422 if (!SWIG_IsOK(res1)) {
49423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49424 }
49425 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49426 {
49427 PyThreadState* __tstate = wxPyBeginAllowThreads();
49428 {
49429 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
49430 result = (wxArrayInt *) &_result_ref;
49431 }
49432 wxPyEndAllowThreads(__tstate);
49433 if (PyErr_Occurred()) SWIG_fail;
49434 }
49435 {
49436 resultobj = PyList_New(0);
49437 size_t idx;
49438 for (idx = 0; idx < result->GetCount(); idx += 1) {
49439 PyObject* val = PyInt_FromLong( result->Item(idx) );
49440 PyList_Append(resultobj, val);
49441 Py_DECREF(val);
49442 }
49443 }
49444 return resultobj;
49445 fail:
49446 return NULL;
49447 }
49448
49449
49450 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49451 PyObject *resultobj = 0;
49452 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49453 wxArrayInt *result = 0 ;
49454 void *argp1 = 0 ;
49455 int res1 = 0 ;
49456 PyObject *swig_obj[1] ;
49457
49458 if (!args) SWIG_fail;
49459 swig_obj[0] = args;
49460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49461 if (!SWIG_IsOK(res1)) {
49462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49463 }
49464 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49465 {
49466 PyThreadState* __tstate = wxPyBeginAllowThreads();
49467 {
49468 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
49469 result = (wxArrayInt *) &_result_ref;
49470 }
49471 wxPyEndAllowThreads(__tstate);
49472 if (PyErr_Occurred()) SWIG_fail;
49473 }
49474 {
49475 resultobj = PyList_New(0);
49476 size_t idx;
49477 for (idx = 0; idx < result->GetCount(); idx += 1) {
49478 PyObject* val = PyInt_FromLong( result->Item(idx) );
49479 PyList_Append(resultobj, val);
49480 Py_DECREF(val);
49481 }
49482 }
49483 return resultobj;
49484 fail:
49485 return NULL;
49486 }
49487
49488
49489 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49490 PyObject *obj;
49491 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49492 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
49493 return SWIG_Py_Void();
49494 }
49495
49496 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49497 return SWIG_Python_InitShadowInstance(args);
49498 }
49499
49500 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49501 PyObject *resultobj = 0;
49502 wxStdDialogButtonSizer *result = 0 ;
49503
49504 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
49505 {
49506 PyThreadState* __tstate = wxPyBeginAllowThreads();
49507 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
49508 wxPyEndAllowThreads(__tstate);
49509 if (PyErr_Occurred()) SWIG_fail;
49510 }
49511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
49512 return resultobj;
49513 fail:
49514 return NULL;
49515 }
49516
49517
49518 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49519 PyObject *resultobj = 0;
49520 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49521 wxButton *arg2 = (wxButton *) 0 ;
49522 void *argp1 = 0 ;
49523 int res1 = 0 ;
49524 void *argp2 = 0 ;
49525 int res2 = 0 ;
49526 PyObject * obj0 = 0 ;
49527 PyObject * obj1 = 0 ;
49528 char * kwnames[] = {
49529 (char *) "self",(char *) "button", NULL
49530 };
49531
49532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
49533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49534 if (!SWIG_IsOK(res1)) {
49535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49536 }
49537 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49538 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49539 if (!SWIG_IsOK(res2)) {
49540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
49541 }
49542 arg2 = reinterpret_cast< wxButton * >(argp2);
49543 {
49544 PyThreadState* __tstate = wxPyBeginAllowThreads();
49545 (arg1)->AddButton(arg2);
49546 wxPyEndAllowThreads(__tstate);
49547 if (PyErr_Occurred()) SWIG_fail;
49548 }
49549 resultobj = SWIG_Py_Void();
49550 return resultobj;
49551 fail:
49552 return NULL;
49553 }
49554
49555
49556 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49557 PyObject *resultobj = 0;
49558 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49559 void *argp1 = 0 ;
49560 int res1 = 0 ;
49561 PyObject *swig_obj[1] ;
49562
49563 if (!args) SWIG_fail;
49564 swig_obj[0] = args;
49565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49566 if (!SWIG_IsOK(res1)) {
49567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49568 }
49569 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49570 {
49571 PyThreadState* __tstate = wxPyBeginAllowThreads();
49572 (arg1)->Realize();
49573 wxPyEndAllowThreads(__tstate);
49574 if (PyErr_Occurred()) SWIG_fail;
49575 }
49576 resultobj = SWIG_Py_Void();
49577 return resultobj;
49578 fail:
49579 return NULL;
49580 }
49581
49582
49583 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49584 PyObject *resultobj = 0;
49585 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49586 wxButton *arg2 = (wxButton *) 0 ;
49587 void *argp1 = 0 ;
49588 int res1 = 0 ;
49589 void *argp2 = 0 ;
49590 int res2 = 0 ;
49591 PyObject * obj0 = 0 ;
49592 PyObject * obj1 = 0 ;
49593 char * kwnames[] = {
49594 (char *) "self",(char *) "button", NULL
49595 };
49596
49597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49599 if (!SWIG_IsOK(res1)) {
49600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49601 }
49602 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49603 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49604 if (!SWIG_IsOK(res2)) {
49605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49606 }
49607 arg2 = reinterpret_cast< wxButton * >(argp2);
49608 {
49609 PyThreadState* __tstate = wxPyBeginAllowThreads();
49610 (arg1)->SetAffirmativeButton(arg2);
49611 wxPyEndAllowThreads(__tstate);
49612 if (PyErr_Occurred()) SWIG_fail;
49613 }
49614 resultobj = SWIG_Py_Void();
49615 return resultobj;
49616 fail:
49617 return NULL;
49618 }
49619
49620
49621 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49622 PyObject *resultobj = 0;
49623 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49624 wxButton *arg2 = (wxButton *) 0 ;
49625 void *argp1 = 0 ;
49626 int res1 = 0 ;
49627 void *argp2 = 0 ;
49628 int res2 = 0 ;
49629 PyObject * obj0 = 0 ;
49630 PyObject * obj1 = 0 ;
49631 char * kwnames[] = {
49632 (char *) "self",(char *) "button", NULL
49633 };
49634
49635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49637 if (!SWIG_IsOK(res1)) {
49638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49639 }
49640 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49641 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49642 if (!SWIG_IsOK(res2)) {
49643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49644 }
49645 arg2 = reinterpret_cast< wxButton * >(argp2);
49646 {
49647 PyThreadState* __tstate = wxPyBeginAllowThreads();
49648 (arg1)->SetNegativeButton(arg2);
49649 wxPyEndAllowThreads(__tstate);
49650 if (PyErr_Occurred()) SWIG_fail;
49651 }
49652 resultobj = SWIG_Py_Void();
49653 return resultobj;
49654 fail:
49655 return NULL;
49656 }
49657
49658
49659 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49660 PyObject *resultobj = 0;
49661 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49662 wxButton *arg2 = (wxButton *) 0 ;
49663 void *argp1 = 0 ;
49664 int res1 = 0 ;
49665 void *argp2 = 0 ;
49666 int res2 = 0 ;
49667 PyObject * obj0 = 0 ;
49668 PyObject * obj1 = 0 ;
49669 char * kwnames[] = {
49670 (char *) "self",(char *) "button", NULL
49671 };
49672
49673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49675 if (!SWIG_IsOK(res1)) {
49676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49677 }
49678 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49679 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49680 if (!SWIG_IsOK(res2)) {
49681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49682 }
49683 arg2 = reinterpret_cast< wxButton * >(argp2);
49684 {
49685 PyThreadState* __tstate = wxPyBeginAllowThreads();
49686 (arg1)->SetCancelButton(arg2);
49687 wxPyEndAllowThreads(__tstate);
49688 if (PyErr_Occurred()) SWIG_fail;
49689 }
49690 resultobj = SWIG_Py_Void();
49691 return resultobj;
49692 fail:
49693 return NULL;
49694 }
49695
49696
49697 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49698 PyObject *resultobj = 0;
49699 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49700 wxButton *result = 0 ;
49701 void *argp1 = 0 ;
49702 int res1 = 0 ;
49703 PyObject *swig_obj[1] ;
49704
49705 if (!args) SWIG_fail;
49706 swig_obj[0] = args;
49707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49708 if (!SWIG_IsOK(res1)) {
49709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49710 }
49711 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49712 {
49713 PyThreadState* __tstate = wxPyBeginAllowThreads();
49714 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49715 wxPyEndAllowThreads(__tstate);
49716 if (PyErr_Occurred()) SWIG_fail;
49717 }
49718 {
49719 resultobj = wxPyMake_wxObject(result, (bool)0);
49720 }
49721 return resultobj;
49722 fail:
49723 return NULL;
49724 }
49725
49726
49727 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49728 PyObject *resultobj = 0;
49729 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49730 wxButton *result = 0 ;
49731 void *argp1 = 0 ;
49732 int res1 = 0 ;
49733 PyObject *swig_obj[1] ;
49734
49735 if (!args) SWIG_fail;
49736 swig_obj[0] = args;
49737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49738 if (!SWIG_IsOK(res1)) {
49739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49740 }
49741 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49742 {
49743 PyThreadState* __tstate = wxPyBeginAllowThreads();
49744 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49745 wxPyEndAllowThreads(__tstate);
49746 if (PyErr_Occurred()) SWIG_fail;
49747 }
49748 {
49749 resultobj = wxPyMake_wxObject(result, (bool)0);
49750 }
49751 return resultobj;
49752 fail:
49753 return NULL;
49754 }
49755
49756
49757 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49758 PyObject *resultobj = 0;
49759 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49760 wxButton *result = 0 ;
49761 void *argp1 = 0 ;
49762 int res1 = 0 ;
49763 PyObject *swig_obj[1] ;
49764
49765 if (!args) SWIG_fail;
49766 swig_obj[0] = args;
49767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49768 if (!SWIG_IsOK(res1)) {
49769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49770 }
49771 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49772 {
49773 PyThreadState* __tstate = wxPyBeginAllowThreads();
49774 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49775 wxPyEndAllowThreads(__tstate);
49776 if (PyErr_Occurred()) SWIG_fail;
49777 }
49778 {
49779 resultobj = wxPyMake_wxObject(result, (bool)0);
49780 }
49781 return resultobj;
49782 fail:
49783 return NULL;
49784 }
49785
49786
49787 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49788 PyObject *resultobj = 0;
49789 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49790 wxButton *result = 0 ;
49791 void *argp1 = 0 ;
49792 int res1 = 0 ;
49793 PyObject *swig_obj[1] ;
49794
49795 if (!args) SWIG_fail;
49796 swig_obj[0] = args;
49797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49798 if (!SWIG_IsOK(res1)) {
49799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49800 }
49801 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49802 {
49803 PyThreadState* __tstate = wxPyBeginAllowThreads();
49804 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49805 wxPyEndAllowThreads(__tstate);
49806 if (PyErr_Occurred()) SWIG_fail;
49807 }
49808 {
49809 resultobj = wxPyMake_wxObject(result, (bool)0);
49810 }
49811 return resultobj;
49812 fail:
49813 return NULL;
49814 }
49815
49816
49817 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49818 PyObject *resultobj = 0;
49819 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49820 wxButton *result = 0 ;
49821 void *argp1 = 0 ;
49822 int res1 = 0 ;
49823 PyObject *swig_obj[1] ;
49824
49825 if (!args) SWIG_fail;
49826 swig_obj[0] = args;
49827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49828 if (!SWIG_IsOK(res1)) {
49829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49830 }
49831 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49832 {
49833 PyThreadState* __tstate = wxPyBeginAllowThreads();
49834 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49835 wxPyEndAllowThreads(__tstate);
49836 if (PyErr_Occurred()) SWIG_fail;
49837 }
49838 {
49839 resultobj = wxPyMake_wxObject(result, (bool)0);
49840 }
49841 return resultobj;
49842 fail:
49843 return NULL;
49844 }
49845
49846
49847 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49848 PyObject *obj;
49849 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49850 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49851 return SWIG_Py_Void();
49852 }
49853
49854 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49855 return SWIG_Python_InitShadowInstance(args);
49856 }
49857
49858 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49859 PyObject *resultobj = 0;
49860 int arg1 = (int) 0 ;
49861 int arg2 = (int) 0 ;
49862 wxGBPosition *result = 0 ;
49863 int val1 ;
49864 int ecode1 = 0 ;
49865 int val2 ;
49866 int ecode2 = 0 ;
49867 PyObject * obj0 = 0 ;
49868 PyObject * obj1 = 0 ;
49869 char * kwnames[] = {
49870 (char *) "row",(char *) "col", NULL
49871 };
49872
49873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49874 if (obj0) {
49875 ecode1 = SWIG_AsVal_int(obj0, &val1);
49876 if (!SWIG_IsOK(ecode1)) {
49877 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49878 }
49879 arg1 = static_cast< int >(val1);
49880 }
49881 if (obj1) {
49882 ecode2 = SWIG_AsVal_int(obj1, &val2);
49883 if (!SWIG_IsOK(ecode2)) {
49884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49885 }
49886 arg2 = static_cast< int >(val2);
49887 }
49888 {
49889 PyThreadState* __tstate = wxPyBeginAllowThreads();
49890 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49891 wxPyEndAllowThreads(__tstate);
49892 if (PyErr_Occurred()) SWIG_fail;
49893 }
49894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49895 return resultobj;
49896 fail:
49897 return NULL;
49898 }
49899
49900
49901 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49902 PyObject *resultobj = 0;
49903 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49904 void *argp1 = 0 ;
49905 int res1 = 0 ;
49906 PyObject *swig_obj[1] ;
49907
49908 if (!args) SWIG_fail;
49909 swig_obj[0] = args;
49910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49911 if (!SWIG_IsOK(res1)) {
49912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49913 }
49914 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49915 {
49916 PyThreadState* __tstate = wxPyBeginAllowThreads();
49917 delete arg1;
49918
49919 wxPyEndAllowThreads(__tstate);
49920 if (PyErr_Occurred()) SWIG_fail;
49921 }
49922 resultobj = SWIG_Py_Void();
49923 return resultobj;
49924 fail:
49925 return NULL;
49926 }
49927
49928
49929 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49930 PyObject *resultobj = 0;
49931 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49932 int result;
49933 void *argp1 = 0 ;
49934 int res1 = 0 ;
49935 PyObject *swig_obj[1] ;
49936
49937 if (!args) SWIG_fail;
49938 swig_obj[0] = args;
49939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49940 if (!SWIG_IsOK(res1)) {
49941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49942 }
49943 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49944 {
49945 PyThreadState* __tstate = wxPyBeginAllowThreads();
49946 result = (int)((wxGBPosition const *)arg1)->GetRow();
49947 wxPyEndAllowThreads(__tstate);
49948 if (PyErr_Occurred()) SWIG_fail;
49949 }
49950 resultobj = SWIG_From_int(static_cast< int >(result));
49951 return resultobj;
49952 fail:
49953 return NULL;
49954 }
49955
49956
49957 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49958 PyObject *resultobj = 0;
49959 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49960 int result;
49961 void *argp1 = 0 ;
49962 int res1 = 0 ;
49963 PyObject *swig_obj[1] ;
49964
49965 if (!args) SWIG_fail;
49966 swig_obj[0] = args;
49967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49968 if (!SWIG_IsOK(res1)) {
49969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49970 }
49971 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49972 {
49973 PyThreadState* __tstate = wxPyBeginAllowThreads();
49974 result = (int)((wxGBPosition const *)arg1)->GetCol();
49975 wxPyEndAllowThreads(__tstate);
49976 if (PyErr_Occurred()) SWIG_fail;
49977 }
49978 resultobj = SWIG_From_int(static_cast< int >(result));
49979 return resultobj;
49980 fail:
49981 return NULL;
49982 }
49983
49984
49985 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49986 PyObject *resultobj = 0;
49987 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49988 int arg2 ;
49989 void *argp1 = 0 ;
49990 int res1 = 0 ;
49991 int val2 ;
49992 int ecode2 = 0 ;
49993 PyObject * obj0 = 0 ;
49994 PyObject * obj1 = 0 ;
49995 char * kwnames[] = {
49996 (char *) "self",(char *) "row", NULL
49997 };
49998
49999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50001 if (!SWIG_IsOK(res1)) {
50002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50003 }
50004 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50005 ecode2 = SWIG_AsVal_int(obj1, &val2);
50006 if (!SWIG_IsOK(ecode2)) {
50007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50008 }
50009 arg2 = static_cast< int >(val2);
50010 {
50011 PyThreadState* __tstate = wxPyBeginAllowThreads();
50012 (arg1)->SetRow(arg2);
50013 wxPyEndAllowThreads(__tstate);
50014 if (PyErr_Occurred()) SWIG_fail;
50015 }
50016 resultobj = SWIG_Py_Void();
50017 return resultobj;
50018 fail:
50019 return NULL;
50020 }
50021
50022
50023 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50024 PyObject *resultobj = 0;
50025 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50026 int arg2 ;
50027 void *argp1 = 0 ;
50028 int res1 = 0 ;
50029 int val2 ;
50030 int ecode2 = 0 ;
50031 PyObject * obj0 = 0 ;
50032 PyObject * obj1 = 0 ;
50033 char * kwnames[] = {
50034 (char *) "self",(char *) "col", NULL
50035 };
50036
50037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50039 if (!SWIG_IsOK(res1)) {
50040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50041 }
50042 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50043 ecode2 = SWIG_AsVal_int(obj1, &val2);
50044 if (!SWIG_IsOK(ecode2)) {
50045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50046 }
50047 arg2 = static_cast< int >(val2);
50048 {
50049 PyThreadState* __tstate = wxPyBeginAllowThreads();
50050 (arg1)->SetCol(arg2);
50051 wxPyEndAllowThreads(__tstate);
50052 if (PyErr_Occurred()) SWIG_fail;
50053 }
50054 resultobj = SWIG_Py_Void();
50055 return resultobj;
50056 fail:
50057 return NULL;
50058 }
50059
50060
50061 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50062 PyObject *resultobj = 0;
50063 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50064 PyObject *arg2 = (PyObject *) 0 ;
50065 bool result;
50066 void *argp1 = 0 ;
50067 int res1 = 0 ;
50068 PyObject * obj0 = 0 ;
50069 PyObject * obj1 = 0 ;
50070 char * kwnames[] = {
50071 (char *) "self",(char *) "other", NULL
50072 };
50073
50074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50076 if (!SWIG_IsOK(res1)) {
50077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50078 }
50079 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50080 arg2 = obj1;
50081 {
50082 result = (bool)wxGBPosition___eq__(arg1,arg2);
50083 if (PyErr_Occurred()) SWIG_fail;
50084 }
50085 {
50086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50087 }
50088 return resultobj;
50089 fail:
50090 return NULL;
50091 }
50092
50093
50094 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50095 PyObject *resultobj = 0;
50096 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50097 PyObject *arg2 = (PyObject *) 0 ;
50098 bool result;
50099 void *argp1 = 0 ;
50100 int res1 = 0 ;
50101 PyObject * obj0 = 0 ;
50102 PyObject * obj1 = 0 ;
50103 char * kwnames[] = {
50104 (char *) "self",(char *) "other", NULL
50105 };
50106
50107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50109 if (!SWIG_IsOK(res1)) {
50110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50111 }
50112 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50113 arg2 = obj1;
50114 {
50115 result = (bool)wxGBPosition___ne__(arg1,arg2);
50116 if (PyErr_Occurred()) SWIG_fail;
50117 }
50118 {
50119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50120 }
50121 return resultobj;
50122 fail:
50123 return NULL;
50124 }
50125
50126
50127 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50128 PyObject *resultobj = 0;
50129 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50130 int arg2 = (int) 0 ;
50131 int arg3 = (int) 0 ;
50132 void *argp1 = 0 ;
50133 int res1 = 0 ;
50134 int val2 ;
50135 int ecode2 = 0 ;
50136 int val3 ;
50137 int ecode3 = 0 ;
50138 PyObject * obj0 = 0 ;
50139 PyObject * obj1 = 0 ;
50140 PyObject * obj2 = 0 ;
50141 char * kwnames[] = {
50142 (char *) "self",(char *) "row",(char *) "col", NULL
50143 };
50144
50145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50147 if (!SWIG_IsOK(res1)) {
50148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50149 }
50150 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50151 if (obj1) {
50152 ecode2 = SWIG_AsVal_int(obj1, &val2);
50153 if (!SWIG_IsOK(ecode2)) {
50154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50155 }
50156 arg2 = static_cast< int >(val2);
50157 }
50158 if (obj2) {
50159 ecode3 = SWIG_AsVal_int(obj2, &val3);
50160 if (!SWIG_IsOK(ecode3)) {
50161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50162 }
50163 arg3 = static_cast< int >(val3);
50164 }
50165 {
50166 PyThreadState* __tstate = wxPyBeginAllowThreads();
50167 wxGBPosition_Set(arg1,arg2,arg3);
50168 wxPyEndAllowThreads(__tstate);
50169 if (PyErr_Occurred()) SWIG_fail;
50170 }
50171 resultobj = SWIG_Py_Void();
50172 return resultobj;
50173 fail:
50174 return NULL;
50175 }
50176
50177
50178 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50179 PyObject *resultobj = 0;
50180 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50181 PyObject *result = 0 ;
50182 void *argp1 = 0 ;
50183 int res1 = 0 ;
50184 PyObject *swig_obj[1] ;
50185
50186 if (!args) SWIG_fail;
50187 swig_obj[0] = args;
50188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50189 if (!SWIG_IsOK(res1)) {
50190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50191 }
50192 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50193 {
50194 PyThreadState* __tstate = wxPyBeginAllowThreads();
50195 result = (PyObject *)wxGBPosition_Get(arg1);
50196 wxPyEndAllowThreads(__tstate);
50197 if (PyErr_Occurred()) SWIG_fail;
50198 }
50199 resultobj = result;
50200 return resultobj;
50201 fail:
50202 return NULL;
50203 }
50204
50205
50206 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50207 PyObject *obj;
50208 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50209 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50210 return SWIG_Py_Void();
50211 }
50212
50213 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50214 return SWIG_Python_InitShadowInstance(args);
50215 }
50216
50217 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50218 PyObject *resultobj = 0;
50219 int arg1 = (int) 1 ;
50220 int arg2 = (int) 1 ;
50221 wxGBSpan *result = 0 ;
50222 int val1 ;
50223 int ecode1 = 0 ;
50224 int val2 ;
50225 int ecode2 = 0 ;
50226 PyObject * obj0 = 0 ;
50227 PyObject * obj1 = 0 ;
50228 char * kwnames[] = {
50229 (char *) "rowspan",(char *) "colspan", NULL
50230 };
50231
50232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50233 if (obj0) {
50234 ecode1 = SWIG_AsVal_int(obj0, &val1);
50235 if (!SWIG_IsOK(ecode1)) {
50236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50237 }
50238 arg1 = static_cast< int >(val1);
50239 }
50240 if (obj1) {
50241 ecode2 = SWIG_AsVal_int(obj1, &val2);
50242 if (!SWIG_IsOK(ecode2)) {
50243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50244 }
50245 arg2 = static_cast< int >(val2);
50246 }
50247 {
50248 PyThreadState* __tstate = wxPyBeginAllowThreads();
50249 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50250 wxPyEndAllowThreads(__tstate);
50251 if (PyErr_Occurred()) SWIG_fail;
50252 }
50253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50254 return resultobj;
50255 fail:
50256 return NULL;
50257 }
50258
50259
50260 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50261 PyObject *resultobj = 0;
50262 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50263 void *argp1 = 0 ;
50264 int res1 = 0 ;
50265 PyObject *swig_obj[1] ;
50266
50267 if (!args) SWIG_fail;
50268 swig_obj[0] = args;
50269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50270 if (!SWIG_IsOK(res1)) {
50271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50272 }
50273 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50274 {
50275 PyThreadState* __tstate = wxPyBeginAllowThreads();
50276 delete arg1;
50277
50278 wxPyEndAllowThreads(__tstate);
50279 if (PyErr_Occurred()) SWIG_fail;
50280 }
50281 resultobj = SWIG_Py_Void();
50282 return resultobj;
50283 fail:
50284 return NULL;
50285 }
50286
50287
50288 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50289 PyObject *resultobj = 0;
50290 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50291 int result;
50292 void *argp1 = 0 ;
50293 int res1 = 0 ;
50294 PyObject *swig_obj[1] ;
50295
50296 if (!args) SWIG_fail;
50297 swig_obj[0] = args;
50298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50299 if (!SWIG_IsOK(res1)) {
50300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50301 }
50302 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50303 {
50304 PyThreadState* __tstate = wxPyBeginAllowThreads();
50305 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50306 wxPyEndAllowThreads(__tstate);
50307 if (PyErr_Occurred()) SWIG_fail;
50308 }
50309 resultobj = SWIG_From_int(static_cast< int >(result));
50310 return resultobj;
50311 fail:
50312 return NULL;
50313 }
50314
50315
50316 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50317 PyObject *resultobj = 0;
50318 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50319 int result;
50320 void *argp1 = 0 ;
50321 int res1 = 0 ;
50322 PyObject *swig_obj[1] ;
50323
50324 if (!args) SWIG_fail;
50325 swig_obj[0] = args;
50326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50327 if (!SWIG_IsOK(res1)) {
50328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50329 }
50330 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50331 {
50332 PyThreadState* __tstate = wxPyBeginAllowThreads();
50333 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50334 wxPyEndAllowThreads(__tstate);
50335 if (PyErr_Occurred()) SWIG_fail;
50336 }
50337 resultobj = SWIG_From_int(static_cast< int >(result));
50338 return resultobj;
50339 fail:
50340 return NULL;
50341 }
50342
50343
50344 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50345 PyObject *resultobj = 0;
50346 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50347 int arg2 ;
50348 void *argp1 = 0 ;
50349 int res1 = 0 ;
50350 int val2 ;
50351 int ecode2 = 0 ;
50352 PyObject * obj0 = 0 ;
50353 PyObject * obj1 = 0 ;
50354 char * kwnames[] = {
50355 (char *) "self",(char *) "rowspan", NULL
50356 };
50357
50358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50360 if (!SWIG_IsOK(res1)) {
50361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50362 }
50363 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50364 ecode2 = SWIG_AsVal_int(obj1, &val2);
50365 if (!SWIG_IsOK(ecode2)) {
50366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50367 }
50368 arg2 = static_cast< int >(val2);
50369 {
50370 PyThreadState* __tstate = wxPyBeginAllowThreads();
50371 (arg1)->SetRowspan(arg2);
50372 wxPyEndAllowThreads(__tstate);
50373 if (PyErr_Occurred()) SWIG_fail;
50374 }
50375 resultobj = SWIG_Py_Void();
50376 return resultobj;
50377 fail:
50378 return NULL;
50379 }
50380
50381
50382 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50383 PyObject *resultobj = 0;
50384 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50385 int arg2 ;
50386 void *argp1 = 0 ;
50387 int res1 = 0 ;
50388 int val2 ;
50389 int ecode2 = 0 ;
50390 PyObject * obj0 = 0 ;
50391 PyObject * obj1 = 0 ;
50392 char * kwnames[] = {
50393 (char *) "self",(char *) "colspan", NULL
50394 };
50395
50396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50398 if (!SWIG_IsOK(res1)) {
50399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50400 }
50401 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50402 ecode2 = SWIG_AsVal_int(obj1, &val2);
50403 if (!SWIG_IsOK(ecode2)) {
50404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50405 }
50406 arg2 = static_cast< int >(val2);
50407 {
50408 PyThreadState* __tstate = wxPyBeginAllowThreads();
50409 (arg1)->SetColspan(arg2);
50410 wxPyEndAllowThreads(__tstate);
50411 if (PyErr_Occurred()) SWIG_fail;
50412 }
50413 resultobj = SWIG_Py_Void();
50414 return resultobj;
50415 fail:
50416 return NULL;
50417 }
50418
50419
50420 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50421 PyObject *resultobj = 0;
50422 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50423 PyObject *arg2 = (PyObject *) 0 ;
50424 bool result;
50425 void *argp1 = 0 ;
50426 int res1 = 0 ;
50427 PyObject * obj0 = 0 ;
50428 PyObject * obj1 = 0 ;
50429 char * kwnames[] = {
50430 (char *) "self",(char *) "other", NULL
50431 };
50432
50433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50435 if (!SWIG_IsOK(res1)) {
50436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50437 }
50438 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50439 arg2 = obj1;
50440 {
50441 result = (bool)wxGBSpan___eq__(arg1,arg2);
50442 if (PyErr_Occurred()) SWIG_fail;
50443 }
50444 {
50445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50446 }
50447 return resultobj;
50448 fail:
50449 return NULL;
50450 }
50451
50452
50453 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50454 PyObject *resultobj = 0;
50455 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50456 PyObject *arg2 = (PyObject *) 0 ;
50457 bool result;
50458 void *argp1 = 0 ;
50459 int res1 = 0 ;
50460 PyObject * obj0 = 0 ;
50461 PyObject * obj1 = 0 ;
50462 char * kwnames[] = {
50463 (char *) "self",(char *) "other", NULL
50464 };
50465
50466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50468 if (!SWIG_IsOK(res1)) {
50469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50470 }
50471 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50472 arg2 = obj1;
50473 {
50474 result = (bool)wxGBSpan___ne__(arg1,arg2);
50475 if (PyErr_Occurred()) SWIG_fail;
50476 }
50477 {
50478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50479 }
50480 return resultobj;
50481 fail:
50482 return NULL;
50483 }
50484
50485
50486 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50487 PyObject *resultobj = 0;
50488 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50489 int arg2 = (int) 1 ;
50490 int arg3 = (int) 1 ;
50491 void *argp1 = 0 ;
50492 int res1 = 0 ;
50493 int val2 ;
50494 int ecode2 = 0 ;
50495 int val3 ;
50496 int ecode3 = 0 ;
50497 PyObject * obj0 = 0 ;
50498 PyObject * obj1 = 0 ;
50499 PyObject * obj2 = 0 ;
50500 char * kwnames[] = {
50501 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
50502 };
50503
50504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50506 if (!SWIG_IsOK(res1)) {
50507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50508 }
50509 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50510 if (obj1) {
50511 ecode2 = SWIG_AsVal_int(obj1, &val2);
50512 if (!SWIG_IsOK(ecode2)) {
50513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
50514 }
50515 arg2 = static_cast< int >(val2);
50516 }
50517 if (obj2) {
50518 ecode3 = SWIG_AsVal_int(obj2, &val3);
50519 if (!SWIG_IsOK(ecode3)) {
50520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
50521 }
50522 arg3 = static_cast< int >(val3);
50523 }
50524 {
50525 PyThreadState* __tstate = wxPyBeginAllowThreads();
50526 wxGBSpan_Set(arg1,arg2,arg3);
50527 wxPyEndAllowThreads(__tstate);
50528 if (PyErr_Occurred()) SWIG_fail;
50529 }
50530 resultobj = SWIG_Py_Void();
50531 return resultobj;
50532 fail:
50533 return NULL;
50534 }
50535
50536
50537 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50538 PyObject *resultobj = 0;
50539 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50540 PyObject *result = 0 ;
50541 void *argp1 = 0 ;
50542 int res1 = 0 ;
50543 PyObject *swig_obj[1] ;
50544
50545 if (!args) SWIG_fail;
50546 swig_obj[0] = args;
50547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50548 if (!SWIG_IsOK(res1)) {
50549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50550 }
50551 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50552 {
50553 PyThreadState* __tstate = wxPyBeginAllowThreads();
50554 result = (PyObject *)wxGBSpan_Get(arg1);
50555 wxPyEndAllowThreads(__tstate);
50556 if (PyErr_Occurred()) SWIG_fail;
50557 }
50558 resultobj = result;
50559 return resultobj;
50560 fail:
50561 return NULL;
50562 }
50563
50564
50565 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50566 PyObject *obj;
50567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50568 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
50569 return SWIG_Py_Void();
50570 }
50571
50572 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50573 return SWIG_Python_InitShadowInstance(args);
50574 }
50575
50576 SWIGINTERN int DefaultSpan_set(PyObject *) {
50577 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
50578 return 1;
50579 }
50580
50581
50582 SWIGINTERN PyObject *DefaultSpan_get(void) {
50583 PyObject *pyobj = 0;
50584
50585 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
50586 return pyobj;
50587 }
50588
50589
50590 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50591 PyObject *resultobj = 0;
50592 wxGBSizerItem *result = 0 ;
50593
50594 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
50595 {
50596 PyThreadState* __tstate = wxPyBeginAllowThreads();
50597 result = (wxGBSizerItem *)new wxGBSizerItem();
50598 wxPyEndAllowThreads(__tstate);
50599 if (PyErr_Occurred()) SWIG_fail;
50600 }
50601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
50602 return resultobj;
50603 fail:
50604 return NULL;
50605 }
50606
50607
50608 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50609 PyObject *resultobj = 0;
50610 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50611 void *argp1 = 0 ;
50612 int res1 = 0 ;
50613 PyObject *swig_obj[1] ;
50614
50615 if (!args) SWIG_fail;
50616 swig_obj[0] = args;
50617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50618 if (!SWIG_IsOK(res1)) {
50619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50620 }
50621 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50622 {
50623 PyThreadState* __tstate = wxPyBeginAllowThreads();
50624 delete arg1;
50625
50626 wxPyEndAllowThreads(__tstate);
50627 if (PyErr_Occurred()) SWIG_fail;
50628 }
50629 resultobj = SWIG_Py_Void();
50630 return resultobj;
50631 fail:
50632 return NULL;
50633 }
50634
50635
50636 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50637 PyObject *resultobj = 0;
50638 wxWindow *arg1 = (wxWindow *) 0 ;
50639 wxGBPosition *arg2 = 0 ;
50640 wxGBSpan *arg3 = 0 ;
50641 int arg4 ;
50642 int arg5 ;
50643 PyObject *arg6 = (PyObject *) NULL ;
50644 wxGBSizerItem *result = 0 ;
50645 void *argp1 = 0 ;
50646 int res1 = 0 ;
50647 wxGBPosition temp2 ;
50648 wxGBSpan temp3 ;
50649 int val4 ;
50650 int ecode4 = 0 ;
50651 int val5 ;
50652 int ecode5 = 0 ;
50653 PyObject * obj0 = 0 ;
50654 PyObject * obj1 = 0 ;
50655 PyObject * obj2 = 0 ;
50656 PyObject * obj3 = 0 ;
50657 PyObject * obj4 = 0 ;
50658 PyObject * obj5 = 0 ;
50659 char * kwnames[] = {
50660 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50661 };
50662
50663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50665 if (!SWIG_IsOK(res1)) {
50666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50667 }
50668 arg1 = reinterpret_cast< wxWindow * >(argp1);
50669 {
50670 arg2 = &temp2;
50671 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50672 }
50673 {
50674 arg3 = &temp3;
50675 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50676 }
50677 ecode4 = SWIG_AsVal_int(obj3, &val4);
50678 if (!SWIG_IsOK(ecode4)) {
50679 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50680 }
50681 arg4 = static_cast< int >(val4);
50682 ecode5 = SWIG_AsVal_int(obj4, &val5);
50683 if (!SWIG_IsOK(ecode5)) {
50684 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50685 }
50686 arg5 = static_cast< int >(val5);
50687 if (obj5) {
50688 arg6 = obj5;
50689 }
50690 {
50691 PyThreadState* __tstate = wxPyBeginAllowThreads();
50692 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50693 wxPyEndAllowThreads(__tstate);
50694 if (PyErr_Occurred()) SWIG_fail;
50695 }
50696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50697 return resultobj;
50698 fail:
50699 return NULL;
50700 }
50701
50702
50703 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50704 PyObject *resultobj = 0;
50705 wxSizer *arg1 = (wxSizer *) 0 ;
50706 wxGBPosition *arg2 = 0 ;
50707 wxGBSpan *arg3 = 0 ;
50708 int arg4 ;
50709 int arg5 ;
50710 PyObject *arg6 = (PyObject *) NULL ;
50711 wxGBSizerItem *result = 0 ;
50712 int res1 = 0 ;
50713 wxGBPosition temp2 ;
50714 wxGBSpan temp3 ;
50715 int val4 ;
50716 int ecode4 = 0 ;
50717 int val5 ;
50718 int ecode5 = 0 ;
50719 PyObject * obj0 = 0 ;
50720 PyObject * obj1 = 0 ;
50721 PyObject * obj2 = 0 ;
50722 PyObject * obj3 = 0 ;
50723 PyObject * obj4 = 0 ;
50724 PyObject * obj5 = 0 ;
50725 char * kwnames[] = {
50726 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50727 };
50728
50729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50730 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50731 if (!SWIG_IsOK(res1)) {
50732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50733 }
50734 {
50735 arg2 = &temp2;
50736 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50737 }
50738 {
50739 arg3 = &temp3;
50740 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50741 }
50742 ecode4 = SWIG_AsVal_int(obj3, &val4);
50743 if (!SWIG_IsOK(ecode4)) {
50744 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50745 }
50746 arg4 = static_cast< int >(val4);
50747 ecode5 = SWIG_AsVal_int(obj4, &val5);
50748 if (!SWIG_IsOK(ecode5)) {
50749 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50750 }
50751 arg5 = static_cast< int >(val5);
50752 if (obj5) {
50753 arg6 = obj5;
50754 }
50755 {
50756 PyThreadState* __tstate = wxPyBeginAllowThreads();
50757 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50758 wxPyEndAllowThreads(__tstate);
50759 if (PyErr_Occurred()) SWIG_fail;
50760 }
50761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50762 return resultobj;
50763 fail:
50764 return NULL;
50765 }
50766
50767
50768 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50769 PyObject *resultobj = 0;
50770 int arg1 ;
50771 int arg2 ;
50772 wxGBPosition *arg3 = 0 ;
50773 wxGBSpan *arg4 = 0 ;
50774 int arg5 ;
50775 int arg6 ;
50776 PyObject *arg7 = (PyObject *) NULL ;
50777 wxGBSizerItem *result = 0 ;
50778 int val1 ;
50779 int ecode1 = 0 ;
50780 int val2 ;
50781 int ecode2 = 0 ;
50782 wxGBPosition temp3 ;
50783 wxGBSpan temp4 ;
50784 int val5 ;
50785 int ecode5 = 0 ;
50786 int val6 ;
50787 int ecode6 = 0 ;
50788 PyObject * obj0 = 0 ;
50789 PyObject * obj1 = 0 ;
50790 PyObject * obj2 = 0 ;
50791 PyObject * obj3 = 0 ;
50792 PyObject * obj4 = 0 ;
50793 PyObject * obj5 = 0 ;
50794 PyObject * obj6 = 0 ;
50795 char * kwnames[] = {
50796 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50797 };
50798
50799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50800 ecode1 = SWIG_AsVal_int(obj0, &val1);
50801 if (!SWIG_IsOK(ecode1)) {
50802 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50803 }
50804 arg1 = static_cast< int >(val1);
50805 ecode2 = SWIG_AsVal_int(obj1, &val2);
50806 if (!SWIG_IsOK(ecode2)) {
50807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50808 }
50809 arg2 = static_cast< int >(val2);
50810 {
50811 arg3 = &temp3;
50812 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50813 }
50814 {
50815 arg4 = &temp4;
50816 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50817 }
50818 ecode5 = SWIG_AsVal_int(obj4, &val5);
50819 if (!SWIG_IsOK(ecode5)) {
50820 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50821 }
50822 arg5 = static_cast< int >(val5);
50823 ecode6 = SWIG_AsVal_int(obj5, &val6);
50824 if (!SWIG_IsOK(ecode6)) {
50825 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50826 }
50827 arg6 = static_cast< int >(val6);
50828 if (obj6) {
50829 arg7 = obj6;
50830 }
50831 {
50832 PyThreadState* __tstate = wxPyBeginAllowThreads();
50833 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50834 wxPyEndAllowThreads(__tstate);
50835 if (PyErr_Occurred()) SWIG_fail;
50836 }
50837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50838 return resultobj;
50839 fail:
50840 return NULL;
50841 }
50842
50843
50844 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50845 PyObject *resultobj = 0;
50846 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50847 wxGBPosition result;
50848 void *argp1 = 0 ;
50849 int res1 = 0 ;
50850 PyObject *swig_obj[1] ;
50851
50852 if (!args) SWIG_fail;
50853 swig_obj[0] = args;
50854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50855 if (!SWIG_IsOK(res1)) {
50856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50857 }
50858 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50859 {
50860 PyThreadState* __tstate = wxPyBeginAllowThreads();
50861 result = ((wxGBSizerItem const *)arg1)->GetPos();
50862 wxPyEndAllowThreads(__tstate);
50863 if (PyErr_Occurred()) SWIG_fail;
50864 }
50865 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50866 return resultobj;
50867 fail:
50868 return NULL;
50869 }
50870
50871
50872 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50873 PyObject *resultobj = 0;
50874 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50875 wxGBSpan result;
50876 void *argp1 = 0 ;
50877 int res1 = 0 ;
50878 PyObject *swig_obj[1] ;
50879
50880 if (!args) SWIG_fail;
50881 swig_obj[0] = args;
50882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50883 if (!SWIG_IsOK(res1)) {
50884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50885 }
50886 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50887 {
50888 PyThreadState* __tstate = wxPyBeginAllowThreads();
50889 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50890 wxPyEndAllowThreads(__tstate);
50891 if (PyErr_Occurred()) SWIG_fail;
50892 }
50893 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50894 return resultobj;
50895 fail:
50896 return NULL;
50897 }
50898
50899
50900 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50901 PyObject *resultobj = 0;
50902 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50903 wxGBPosition *arg2 = 0 ;
50904 bool result;
50905 void *argp1 = 0 ;
50906 int res1 = 0 ;
50907 wxGBPosition temp2 ;
50908 PyObject * obj0 = 0 ;
50909 PyObject * obj1 = 0 ;
50910 char * kwnames[] = {
50911 (char *) "self",(char *) "pos", NULL
50912 };
50913
50914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50916 if (!SWIG_IsOK(res1)) {
50917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50918 }
50919 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50920 {
50921 arg2 = &temp2;
50922 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50923 }
50924 {
50925 PyThreadState* __tstate = wxPyBeginAllowThreads();
50926 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50927 wxPyEndAllowThreads(__tstate);
50928 if (PyErr_Occurred()) SWIG_fail;
50929 }
50930 {
50931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50932 }
50933 return resultobj;
50934 fail:
50935 return NULL;
50936 }
50937
50938
50939 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50940 PyObject *resultobj = 0;
50941 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50942 wxGBSpan *arg2 = 0 ;
50943 bool result;
50944 void *argp1 = 0 ;
50945 int res1 = 0 ;
50946 wxGBSpan temp2 ;
50947 PyObject * obj0 = 0 ;
50948 PyObject * obj1 = 0 ;
50949 char * kwnames[] = {
50950 (char *) "self",(char *) "span", NULL
50951 };
50952
50953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50955 if (!SWIG_IsOK(res1)) {
50956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50957 }
50958 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50959 {
50960 arg2 = &temp2;
50961 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50962 }
50963 {
50964 PyThreadState* __tstate = wxPyBeginAllowThreads();
50965 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50966 wxPyEndAllowThreads(__tstate);
50967 if (PyErr_Occurred()) SWIG_fail;
50968 }
50969 {
50970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50971 }
50972 return resultobj;
50973 fail:
50974 return NULL;
50975 }
50976
50977
50978 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50979 PyObject *resultobj = 0;
50980 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50981 wxGBSizerItem *arg2 = 0 ;
50982 bool result;
50983 void *argp1 = 0 ;
50984 int res1 = 0 ;
50985 void *argp2 = 0 ;
50986 int res2 = 0 ;
50987 PyObject * obj0 = 0 ;
50988 PyObject * obj1 = 0 ;
50989 char * kwnames[] = {
50990 (char *) "self",(char *) "other", NULL
50991 };
50992
50993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50995 if (!SWIG_IsOK(res1)) {
50996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50997 }
50998 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50999 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51000 if (!SWIG_IsOK(res2)) {
51001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51002 }
51003 if (!argp2) {
51004 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51005 }
51006 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51007 {
51008 PyThreadState* __tstate = wxPyBeginAllowThreads();
51009 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51010 wxPyEndAllowThreads(__tstate);
51011 if (PyErr_Occurred()) SWIG_fail;
51012 }
51013 {
51014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51015 }
51016 return resultobj;
51017 fail:
51018 return NULL;
51019 }
51020
51021
51022 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51023 PyObject *resultobj = 0;
51024 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51025 wxGBPosition *arg2 = 0 ;
51026 wxGBSpan *arg3 = 0 ;
51027 bool result;
51028 void *argp1 = 0 ;
51029 int res1 = 0 ;
51030 wxGBPosition temp2 ;
51031 wxGBSpan temp3 ;
51032 PyObject * obj0 = 0 ;
51033 PyObject * obj1 = 0 ;
51034 PyObject * obj2 = 0 ;
51035 char * kwnames[] = {
51036 (char *) "self",(char *) "pos",(char *) "span", NULL
51037 };
51038
51039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51041 if (!SWIG_IsOK(res1)) {
51042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51043 }
51044 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51045 {
51046 arg2 = &temp2;
51047 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51048 }
51049 {
51050 arg3 = &temp3;
51051 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51052 }
51053 {
51054 PyThreadState* __tstate = wxPyBeginAllowThreads();
51055 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51056 wxPyEndAllowThreads(__tstate);
51057 if (PyErr_Occurred()) SWIG_fail;
51058 }
51059 {
51060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51061 }
51062 return resultobj;
51063 fail:
51064 return NULL;
51065 }
51066
51067
51068 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51069 PyObject *resultobj = 0;
51070 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51071 wxGBPosition result;
51072 void *argp1 = 0 ;
51073 int res1 = 0 ;
51074 PyObject *swig_obj[1] ;
51075
51076 if (!args) SWIG_fail;
51077 swig_obj[0] = args;
51078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51079 if (!SWIG_IsOK(res1)) {
51080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51081 }
51082 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51083 {
51084 PyThreadState* __tstate = wxPyBeginAllowThreads();
51085 result = wxGBSizerItem_GetEndPos(arg1);
51086 wxPyEndAllowThreads(__tstate);
51087 if (PyErr_Occurred()) SWIG_fail;
51088 }
51089 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51090 return resultobj;
51091 fail:
51092 return NULL;
51093 }
51094
51095
51096 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51097 PyObject *resultobj = 0;
51098 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51099 wxGridBagSizer *result = 0 ;
51100 void *argp1 = 0 ;
51101 int res1 = 0 ;
51102 PyObject *swig_obj[1] ;
51103
51104 if (!args) SWIG_fail;
51105 swig_obj[0] = args;
51106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51107 if (!SWIG_IsOK(res1)) {
51108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51109 }
51110 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51111 {
51112 PyThreadState* __tstate = wxPyBeginAllowThreads();
51113 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51114 wxPyEndAllowThreads(__tstate);
51115 if (PyErr_Occurred()) SWIG_fail;
51116 }
51117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51118 return resultobj;
51119 fail:
51120 return NULL;
51121 }
51122
51123
51124 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51125 PyObject *resultobj = 0;
51126 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51127 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51128 void *argp1 = 0 ;
51129 int res1 = 0 ;
51130 void *argp2 = 0 ;
51131 int res2 = 0 ;
51132 PyObject * obj0 = 0 ;
51133 PyObject * obj1 = 0 ;
51134 char * kwnames[] = {
51135 (char *) "self",(char *) "sizer", NULL
51136 };
51137
51138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51140 if (!SWIG_IsOK(res1)) {
51141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51142 }
51143 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51145 if (!SWIG_IsOK(res2)) {
51146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51147 }
51148 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51149 {
51150 PyThreadState* __tstate = wxPyBeginAllowThreads();
51151 (arg1)->SetGBSizer(arg2);
51152 wxPyEndAllowThreads(__tstate);
51153 if (PyErr_Occurred()) SWIG_fail;
51154 }
51155 resultobj = SWIG_Py_Void();
51156 return resultobj;
51157 fail:
51158 return NULL;
51159 }
51160
51161
51162 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51163 PyObject *obj;
51164 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51165 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51166 return SWIG_Py_Void();
51167 }
51168
51169 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51170 return SWIG_Python_InitShadowInstance(args);
51171 }
51172
51173 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51174 PyObject *resultobj = 0;
51175 int arg1 = (int) 0 ;
51176 int arg2 = (int) 0 ;
51177 wxGridBagSizer *result = 0 ;
51178 int val1 ;
51179 int ecode1 = 0 ;
51180 int val2 ;
51181 int ecode2 = 0 ;
51182 PyObject * obj0 = 0 ;
51183 PyObject * obj1 = 0 ;
51184 char * kwnames[] = {
51185 (char *) "vgap",(char *) "hgap", NULL
51186 };
51187
51188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51189 if (obj0) {
51190 ecode1 = SWIG_AsVal_int(obj0, &val1);
51191 if (!SWIG_IsOK(ecode1)) {
51192 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51193 }
51194 arg1 = static_cast< int >(val1);
51195 }
51196 if (obj1) {
51197 ecode2 = SWIG_AsVal_int(obj1, &val2);
51198 if (!SWIG_IsOK(ecode2)) {
51199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51200 }
51201 arg2 = static_cast< int >(val2);
51202 }
51203 {
51204 PyThreadState* __tstate = wxPyBeginAllowThreads();
51205 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51206 wxPyEndAllowThreads(__tstate);
51207 if (PyErr_Occurred()) SWIG_fail;
51208 }
51209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51210 return resultobj;
51211 fail:
51212 return NULL;
51213 }
51214
51215
51216 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51217 PyObject *resultobj = 0;
51218 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51219 PyObject *arg2 = (PyObject *) 0 ;
51220 wxGBPosition *arg3 = 0 ;
51221 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51222 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51223 int arg5 = (int) 0 ;
51224 int arg6 = (int) 0 ;
51225 PyObject *arg7 = (PyObject *) NULL ;
51226 wxGBSizerItem *result = 0 ;
51227 void *argp1 = 0 ;
51228 int res1 = 0 ;
51229 wxGBPosition temp3 ;
51230 wxGBSpan temp4 ;
51231 int val5 ;
51232 int ecode5 = 0 ;
51233 int val6 ;
51234 int ecode6 = 0 ;
51235 PyObject * obj0 = 0 ;
51236 PyObject * obj1 = 0 ;
51237 PyObject * obj2 = 0 ;
51238 PyObject * obj3 = 0 ;
51239 PyObject * obj4 = 0 ;
51240 PyObject * obj5 = 0 ;
51241 PyObject * obj6 = 0 ;
51242 char * kwnames[] = {
51243 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51244 };
51245
51246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51248 if (!SWIG_IsOK(res1)) {
51249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51250 }
51251 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51252 arg2 = obj1;
51253 {
51254 arg3 = &temp3;
51255 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51256 }
51257 if (obj3) {
51258 {
51259 arg4 = &temp4;
51260 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51261 }
51262 }
51263 if (obj4) {
51264 ecode5 = SWIG_AsVal_int(obj4, &val5);
51265 if (!SWIG_IsOK(ecode5)) {
51266 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51267 }
51268 arg5 = static_cast< int >(val5);
51269 }
51270 if (obj5) {
51271 ecode6 = SWIG_AsVal_int(obj5, &val6);
51272 if (!SWIG_IsOK(ecode6)) {
51273 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51274 }
51275 arg6 = static_cast< int >(val6);
51276 }
51277 if (obj6) {
51278 arg7 = obj6;
51279 }
51280 {
51281 PyThreadState* __tstate = wxPyBeginAllowThreads();
51282 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51283 wxPyEndAllowThreads(__tstate);
51284 if (PyErr_Occurred()) SWIG_fail;
51285 }
51286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51287 return resultobj;
51288 fail:
51289 return NULL;
51290 }
51291
51292
51293 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51294 PyObject *resultobj = 0;
51295 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51296 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51297 wxGBSizerItem *result = 0 ;
51298 void *argp1 = 0 ;
51299 int res1 = 0 ;
51300 int res2 = 0 ;
51301 PyObject * obj0 = 0 ;
51302 PyObject * obj1 = 0 ;
51303 char * kwnames[] = {
51304 (char *) "self",(char *) "item", NULL
51305 };
51306
51307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51309 if (!SWIG_IsOK(res1)) {
51310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51311 }
51312 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51313 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51314 if (!SWIG_IsOK(res2)) {
51315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51316 }
51317 {
51318 PyThreadState* __tstate = wxPyBeginAllowThreads();
51319 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51320 wxPyEndAllowThreads(__tstate);
51321 if (PyErr_Occurred()) SWIG_fail;
51322 }
51323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51324 return resultobj;
51325 fail:
51326 return NULL;
51327 }
51328
51329
51330 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51331 PyObject *resultobj = 0;
51332 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51333 int arg2 ;
51334 int arg3 ;
51335 wxSize result;
51336 void *argp1 = 0 ;
51337 int res1 = 0 ;
51338 int val2 ;
51339 int ecode2 = 0 ;
51340 int val3 ;
51341 int ecode3 = 0 ;
51342 PyObject * obj0 = 0 ;
51343 PyObject * obj1 = 0 ;
51344 PyObject * obj2 = 0 ;
51345 char * kwnames[] = {
51346 (char *) "self",(char *) "row",(char *) "col", NULL
51347 };
51348
51349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51351 if (!SWIG_IsOK(res1)) {
51352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51353 }
51354 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51355 ecode2 = SWIG_AsVal_int(obj1, &val2);
51356 if (!SWIG_IsOK(ecode2)) {
51357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51358 }
51359 arg2 = static_cast< int >(val2);
51360 ecode3 = SWIG_AsVal_int(obj2, &val3);
51361 if (!SWIG_IsOK(ecode3)) {
51362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51363 }
51364 arg3 = static_cast< int >(val3);
51365 {
51366 PyThreadState* __tstate = wxPyBeginAllowThreads();
51367 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51368 wxPyEndAllowThreads(__tstate);
51369 if (PyErr_Occurred()) SWIG_fail;
51370 }
51371 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51372 return resultobj;
51373 fail:
51374 return NULL;
51375 }
51376
51377
51378 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51379 PyObject *resultobj = 0;
51380 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51381 wxSize result;
51382 void *argp1 = 0 ;
51383 int res1 = 0 ;
51384 PyObject *swig_obj[1] ;
51385
51386 if (!args) SWIG_fail;
51387 swig_obj[0] = args;
51388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51389 if (!SWIG_IsOK(res1)) {
51390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51391 }
51392 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51393 {
51394 PyThreadState* __tstate = wxPyBeginAllowThreads();
51395 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51396 wxPyEndAllowThreads(__tstate);
51397 if (PyErr_Occurred()) SWIG_fail;
51398 }
51399 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51400 return resultobj;
51401 fail:
51402 return NULL;
51403 }
51404
51405
51406 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51407 PyObject *resultobj = 0;
51408 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51409 wxSize *arg2 = 0 ;
51410 void *argp1 = 0 ;
51411 int res1 = 0 ;
51412 wxSize temp2 ;
51413 PyObject * obj0 = 0 ;
51414 PyObject * obj1 = 0 ;
51415 char * kwnames[] = {
51416 (char *) "self",(char *) "sz", NULL
51417 };
51418
51419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51421 if (!SWIG_IsOK(res1)) {
51422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51423 }
51424 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51425 {
51426 arg2 = &temp2;
51427 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51428 }
51429 {
51430 PyThreadState* __tstate = wxPyBeginAllowThreads();
51431 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51432 wxPyEndAllowThreads(__tstate);
51433 if (PyErr_Occurred()) SWIG_fail;
51434 }
51435 resultobj = SWIG_Py_Void();
51436 return resultobj;
51437 fail:
51438 return NULL;
51439 }
51440
51441
51442 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51443 PyObject *resultobj = 0;
51444 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51445 wxWindow *arg2 = (wxWindow *) 0 ;
51446 wxGBPosition result;
51447 void *argp1 = 0 ;
51448 int res1 = 0 ;
51449 void *argp2 = 0 ;
51450 int res2 = 0 ;
51451
51452 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51454 if (!SWIG_IsOK(res1)) {
51455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51456 }
51457 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51458 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51459 if (!SWIG_IsOK(res2)) {
51460 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51461 }
51462 arg2 = reinterpret_cast< wxWindow * >(argp2);
51463 {
51464 PyThreadState* __tstate = wxPyBeginAllowThreads();
51465 result = (arg1)->GetItemPosition(arg2);
51466 wxPyEndAllowThreads(__tstate);
51467 if (PyErr_Occurred()) SWIG_fail;
51468 }
51469 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51470 return resultobj;
51471 fail:
51472 return NULL;
51473 }
51474
51475
51476 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51477 PyObject *resultobj = 0;
51478 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51479 wxSizer *arg2 = (wxSizer *) 0 ;
51480 wxGBPosition result;
51481 void *argp1 = 0 ;
51482 int res1 = 0 ;
51483 void *argp2 = 0 ;
51484 int res2 = 0 ;
51485
51486 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51488 if (!SWIG_IsOK(res1)) {
51489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51490 }
51491 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51492 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51493 if (!SWIG_IsOK(res2)) {
51494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51495 }
51496 arg2 = reinterpret_cast< wxSizer * >(argp2);
51497 {
51498 PyThreadState* __tstate = wxPyBeginAllowThreads();
51499 result = (arg1)->GetItemPosition(arg2);
51500 wxPyEndAllowThreads(__tstate);
51501 if (PyErr_Occurred()) SWIG_fail;
51502 }
51503 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51504 return resultobj;
51505 fail:
51506 return NULL;
51507 }
51508
51509
51510 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51511 PyObject *resultobj = 0;
51512 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51513 size_t arg2 ;
51514 wxGBPosition result;
51515 void *argp1 = 0 ;
51516 int res1 = 0 ;
51517 size_t val2 ;
51518 int ecode2 = 0 ;
51519
51520 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51522 if (!SWIG_IsOK(res1)) {
51523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51524 }
51525 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51526 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51527 if (!SWIG_IsOK(ecode2)) {
51528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51529 }
51530 arg2 = static_cast< size_t >(val2);
51531 {
51532 PyThreadState* __tstate = wxPyBeginAllowThreads();
51533 result = (arg1)->GetItemPosition(arg2);
51534 wxPyEndAllowThreads(__tstate);
51535 if (PyErr_Occurred()) SWIG_fail;
51536 }
51537 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51538 return resultobj;
51539 fail:
51540 return NULL;
51541 }
51542
51543
51544 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
51545 int argc;
51546 PyObject *argv[3];
51547
51548 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
51549 --argc;
51550 if (argc == 2) {
51551 int _v = 0;
51552 {
51553 void *vptr = 0;
51554 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51555 _v = SWIG_CheckState(res);
51556 }
51557 if (!_v) goto check_1;
51558 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
51559 }
51560 check_1:
51561
51562 if (argc == 2) {
51563 int _v = 0;
51564 {
51565 void *vptr = 0;
51566 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51567 _v = SWIG_CheckState(res);
51568 }
51569 if (!_v) goto check_2;
51570 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
51571 }
51572 check_2:
51573
51574 if (argc == 2) {
51575 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
51576 }
51577
51578 fail:
51579 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
51580 return NULL;
51581 }
51582
51583
51584 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51585 PyObject *resultobj = 0;
51586 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51587 wxWindow *arg2 = (wxWindow *) 0 ;
51588 wxGBPosition *arg3 = 0 ;
51589 bool result;
51590 void *argp1 = 0 ;
51591 int res1 = 0 ;
51592 void *argp2 = 0 ;
51593 int res2 = 0 ;
51594 wxGBPosition temp3 ;
51595
51596 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51598 if (!SWIG_IsOK(res1)) {
51599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51600 }
51601 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51602 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51603 if (!SWIG_IsOK(res2)) {
51604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51605 }
51606 arg2 = reinterpret_cast< wxWindow * >(argp2);
51607 {
51608 arg3 = &temp3;
51609 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51610 }
51611 {
51612 PyThreadState* __tstate = wxPyBeginAllowThreads();
51613 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51614 wxPyEndAllowThreads(__tstate);
51615 if (PyErr_Occurred()) SWIG_fail;
51616 }
51617 {
51618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51619 }
51620 return resultobj;
51621 fail:
51622 return NULL;
51623 }
51624
51625
51626 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51627 PyObject *resultobj = 0;
51628 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51629 wxSizer *arg2 = (wxSizer *) 0 ;
51630 wxGBPosition *arg3 = 0 ;
51631 bool result;
51632 void *argp1 = 0 ;
51633 int res1 = 0 ;
51634 void *argp2 = 0 ;
51635 int res2 = 0 ;
51636 wxGBPosition temp3 ;
51637
51638 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51640 if (!SWIG_IsOK(res1)) {
51641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51642 }
51643 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51644 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51645 if (!SWIG_IsOK(res2)) {
51646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51647 }
51648 arg2 = reinterpret_cast< wxSizer * >(argp2);
51649 {
51650 arg3 = &temp3;
51651 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51652 }
51653 {
51654 PyThreadState* __tstate = wxPyBeginAllowThreads();
51655 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51656 wxPyEndAllowThreads(__tstate);
51657 if (PyErr_Occurred()) SWIG_fail;
51658 }
51659 {
51660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51661 }
51662 return resultobj;
51663 fail:
51664 return NULL;
51665 }
51666
51667
51668 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51669 PyObject *resultobj = 0;
51670 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51671 size_t arg2 ;
51672 wxGBPosition *arg3 = 0 ;
51673 bool result;
51674 void *argp1 = 0 ;
51675 int res1 = 0 ;
51676 size_t val2 ;
51677 int ecode2 = 0 ;
51678 wxGBPosition temp3 ;
51679
51680 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51682 if (!SWIG_IsOK(res1)) {
51683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51684 }
51685 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51686 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51687 if (!SWIG_IsOK(ecode2)) {
51688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51689 }
51690 arg2 = static_cast< size_t >(val2);
51691 {
51692 arg3 = &temp3;
51693 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51694 }
51695 {
51696 PyThreadState* __tstate = wxPyBeginAllowThreads();
51697 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51698 wxPyEndAllowThreads(__tstate);
51699 if (PyErr_Occurred()) SWIG_fail;
51700 }
51701 {
51702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51703 }
51704 return resultobj;
51705 fail:
51706 return NULL;
51707 }
51708
51709
51710 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51711 int argc;
51712 PyObject *argv[4];
51713
51714 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51715 --argc;
51716 if (argc == 3) {
51717 int _v = 0;
51718 {
51719 void *vptr = 0;
51720 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51721 _v = SWIG_CheckState(res);
51722 }
51723 if (!_v) goto check_1;
51724 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51725 }
51726 check_1:
51727
51728 if (argc == 3) {
51729 int _v = 0;
51730 {
51731 void *vptr = 0;
51732 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51733 _v = SWIG_CheckState(res);
51734 }
51735 if (!_v) goto check_2;
51736 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51737 }
51738 check_2:
51739
51740 if (argc == 3) {
51741 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51742 }
51743
51744 fail:
51745 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51746 return NULL;
51747 }
51748
51749
51750 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51751 PyObject *resultobj = 0;
51752 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51753 wxWindow *arg2 = (wxWindow *) 0 ;
51754 wxGBSpan result;
51755 void *argp1 = 0 ;
51756 int res1 = 0 ;
51757 void *argp2 = 0 ;
51758 int res2 = 0 ;
51759
51760 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51762 if (!SWIG_IsOK(res1)) {
51763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51764 }
51765 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51766 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51767 if (!SWIG_IsOK(res2)) {
51768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51769 }
51770 arg2 = reinterpret_cast< wxWindow * >(argp2);
51771 {
51772 PyThreadState* __tstate = wxPyBeginAllowThreads();
51773 result = (arg1)->GetItemSpan(arg2);
51774 wxPyEndAllowThreads(__tstate);
51775 if (PyErr_Occurred()) SWIG_fail;
51776 }
51777 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51778 return resultobj;
51779 fail:
51780 return NULL;
51781 }
51782
51783
51784 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51785 PyObject *resultobj = 0;
51786 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51787 wxSizer *arg2 = (wxSizer *) 0 ;
51788 wxGBSpan result;
51789 void *argp1 = 0 ;
51790 int res1 = 0 ;
51791 void *argp2 = 0 ;
51792 int res2 = 0 ;
51793
51794 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51796 if (!SWIG_IsOK(res1)) {
51797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51798 }
51799 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51800 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51801 if (!SWIG_IsOK(res2)) {
51802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51803 }
51804 arg2 = reinterpret_cast< wxSizer * >(argp2);
51805 {
51806 PyThreadState* __tstate = wxPyBeginAllowThreads();
51807 result = (arg1)->GetItemSpan(arg2);
51808 wxPyEndAllowThreads(__tstate);
51809 if (PyErr_Occurred()) SWIG_fail;
51810 }
51811 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51812 return resultobj;
51813 fail:
51814 return NULL;
51815 }
51816
51817
51818 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51819 PyObject *resultobj = 0;
51820 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51821 size_t arg2 ;
51822 wxGBSpan result;
51823 void *argp1 = 0 ;
51824 int res1 = 0 ;
51825 size_t val2 ;
51826 int ecode2 = 0 ;
51827
51828 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51830 if (!SWIG_IsOK(res1)) {
51831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51832 }
51833 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51834 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51835 if (!SWIG_IsOK(ecode2)) {
51836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51837 }
51838 arg2 = static_cast< size_t >(val2);
51839 {
51840 PyThreadState* __tstate = wxPyBeginAllowThreads();
51841 result = (arg1)->GetItemSpan(arg2);
51842 wxPyEndAllowThreads(__tstate);
51843 if (PyErr_Occurred()) SWIG_fail;
51844 }
51845 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51846 return resultobj;
51847 fail:
51848 return NULL;
51849 }
51850
51851
51852 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51853 int argc;
51854 PyObject *argv[3];
51855
51856 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51857 --argc;
51858 if (argc == 2) {
51859 int _v = 0;
51860 {
51861 void *vptr = 0;
51862 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51863 _v = SWIG_CheckState(res);
51864 }
51865 if (!_v) goto check_1;
51866 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51867 }
51868 check_1:
51869
51870 if (argc == 2) {
51871 int _v = 0;
51872 {
51873 void *vptr = 0;
51874 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51875 _v = SWIG_CheckState(res);
51876 }
51877 if (!_v) goto check_2;
51878 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51879 }
51880 check_2:
51881
51882 if (argc == 2) {
51883 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51884 }
51885
51886 fail:
51887 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51888 return NULL;
51889 }
51890
51891
51892 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51893 PyObject *resultobj = 0;
51894 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51895 wxWindow *arg2 = (wxWindow *) 0 ;
51896 wxGBSpan *arg3 = 0 ;
51897 bool result;
51898 void *argp1 = 0 ;
51899 int res1 = 0 ;
51900 void *argp2 = 0 ;
51901 int res2 = 0 ;
51902 wxGBSpan temp3 ;
51903
51904 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51906 if (!SWIG_IsOK(res1)) {
51907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51908 }
51909 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51910 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51911 if (!SWIG_IsOK(res2)) {
51912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51913 }
51914 arg2 = reinterpret_cast< wxWindow * >(argp2);
51915 {
51916 arg3 = &temp3;
51917 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51918 }
51919 {
51920 PyThreadState* __tstate = wxPyBeginAllowThreads();
51921 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51922 wxPyEndAllowThreads(__tstate);
51923 if (PyErr_Occurred()) SWIG_fail;
51924 }
51925 {
51926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51927 }
51928 return resultobj;
51929 fail:
51930 return NULL;
51931 }
51932
51933
51934 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51935 PyObject *resultobj = 0;
51936 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51937 wxSizer *arg2 = (wxSizer *) 0 ;
51938 wxGBSpan *arg3 = 0 ;
51939 bool result;
51940 void *argp1 = 0 ;
51941 int res1 = 0 ;
51942 void *argp2 = 0 ;
51943 int res2 = 0 ;
51944 wxGBSpan temp3 ;
51945
51946 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51948 if (!SWIG_IsOK(res1)) {
51949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51950 }
51951 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51952 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51953 if (!SWIG_IsOK(res2)) {
51954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51955 }
51956 arg2 = reinterpret_cast< wxSizer * >(argp2);
51957 {
51958 arg3 = &temp3;
51959 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51960 }
51961 {
51962 PyThreadState* __tstate = wxPyBeginAllowThreads();
51963 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51964 wxPyEndAllowThreads(__tstate);
51965 if (PyErr_Occurred()) SWIG_fail;
51966 }
51967 {
51968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51969 }
51970 return resultobj;
51971 fail:
51972 return NULL;
51973 }
51974
51975
51976 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51977 PyObject *resultobj = 0;
51978 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51979 size_t arg2 ;
51980 wxGBSpan *arg3 = 0 ;
51981 bool result;
51982 void *argp1 = 0 ;
51983 int res1 = 0 ;
51984 size_t val2 ;
51985 int ecode2 = 0 ;
51986 wxGBSpan temp3 ;
51987
51988 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51990 if (!SWIG_IsOK(res1)) {
51991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51992 }
51993 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51994 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51995 if (!SWIG_IsOK(ecode2)) {
51996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51997 }
51998 arg2 = static_cast< size_t >(val2);
51999 {
52000 arg3 = &temp3;
52001 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52002 }
52003 {
52004 PyThreadState* __tstate = wxPyBeginAllowThreads();
52005 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52006 wxPyEndAllowThreads(__tstate);
52007 if (PyErr_Occurred()) SWIG_fail;
52008 }
52009 {
52010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52011 }
52012 return resultobj;
52013 fail:
52014 return NULL;
52015 }
52016
52017
52018 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52019 int argc;
52020 PyObject *argv[4];
52021
52022 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52023 --argc;
52024 if (argc == 3) {
52025 int _v = 0;
52026 {
52027 void *vptr = 0;
52028 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52029 _v = SWIG_CheckState(res);
52030 }
52031 if (!_v) goto check_1;
52032 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52033 }
52034 check_1:
52035
52036 if (argc == 3) {
52037 int _v = 0;
52038 {
52039 void *vptr = 0;
52040 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52041 _v = SWIG_CheckState(res);
52042 }
52043 if (!_v) goto check_2;
52044 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52045 }
52046 check_2:
52047
52048 if (argc == 3) {
52049 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52050 }
52051
52052 fail:
52053 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52054 return NULL;
52055 }
52056
52057
52058 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52059 PyObject *resultobj = 0;
52060 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52061 wxWindow *arg2 = (wxWindow *) 0 ;
52062 wxGBSizerItem *result = 0 ;
52063 void *argp1 = 0 ;
52064 int res1 = 0 ;
52065 void *argp2 = 0 ;
52066 int res2 = 0 ;
52067
52068 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52070 if (!SWIG_IsOK(res1)) {
52071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52072 }
52073 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52074 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52075 if (!SWIG_IsOK(res2)) {
52076 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52077 }
52078 arg2 = reinterpret_cast< wxWindow * >(argp2);
52079 {
52080 PyThreadState* __tstate = wxPyBeginAllowThreads();
52081 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52082 wxPyEndAllowThreads(__tstate);
52083 if (PyErr_Occurred()) SWIG_fail;
52084 }
52085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52086 return resultobj;
52087 fail:
52088 return NULL;
52089 }
52090
52091
52092 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52093 PyObject *resultobj = 0;
52094 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52095 wxSizer *arg2 = (wxSizer *) 0 ;
52096 wxGBSizerItem *result = 0 ;
52097 void *argp1 = 0 ;
52098 int res1 = 0 ;
52099 void *argp2 = 0 ;
52100 int res2 = 0 ;
52101
52102 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52104 if (!SWIG_IsOK(res1)) {
52105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52106 }
52107 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52108 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52109 if (!SWIG_IsOK(res2)) {
52110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52111 }
52112 arg2 = reinterpret_cast< wxSizer * >(argp2);
52113 {
52114 PyThreadState* __tstate = wxPyBeginAllowThreads();
52115 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52116 wxPyEndAllowThreads(__tstate);
52117 if (PyErr_Occurred()) SWIG_fail;
52118 }
52119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52120 return resultobj;
52121 fail:
52122 return NULL;
52123 }
52124
52125
52126 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52127 int argc;
52128 PyObject *argv[3];
52129
52130 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52131 --argc;
52132 if (argc == 2) {
52133 int _v = 0;
52134 {
52135 void *vptr = 0;
52136 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52137 _v = SWIG_CheckState(res);
52138 }
52139 if (!_v) goto check_1;
52140 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52141 }
52142 check_1:
52143
52144 if (argc == 2) {
52145 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52146 }
52147
52148 fail:
52149 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52150 return NULL;
52151 }
52152
52153
52154 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52155 PyObject *resultobj = 0;
52156 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52157 wxGBPosition *arg2 = 0 ;
52158 wxGBSizerItem *result = 0 ;
52159 void *argp1 = 0 ;
52160 int res1 = 0 ;
52161 wxGBPosition temp2 ;
52162 PyObject * obj0 = 0 ;
52163 PyObject * obj1 = 0 ;
52164 char * kwnames[] = {
52165 (char *) "self",(char *) "pos", NULL
52166 };
52167
52168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52170 if (!SWIG_IsOK(res1)) {
52171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52172 }
52173 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52174 {
52175 arg2 = &temp2;
52176 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52177 }
52178 {
52179 PyThreadState* __tstate = wxPyBeginAllowThreads();
52180 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52181 wxPyEndAllowThreads(__tstate);
52182 if (PyErr_Occurred()) SWIG_fail;
52183 }
52184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52185 return resultobj;
52186 fail:
52187 return NULL;
52188 }
52189
52190
52191 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52192 PyObject *resultobj = 0;
52193 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52194 wxPoint *arg2 = 0 ;
52195 wxGBSizerItem *result = 0 ;
52196 void *argp1 = 0 ;
52197 int res1 = 0 ;
52198 wxPoint temp2 ;
52199 PyObject * obj0 = 0 ;
52200 PyObject * obj1 = 0 ;
52201 char * kwnames[] = {
52202 (char *) "self",(char *) "pt", NULL
52203 };
52204
52205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52207 if (!SWIG_IsOK(res1)) {
52208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52209 }
52210 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52211 {
52212 arg2 = &temp2;
52213 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52214 }
52215 {
52216 PyThreadState* __tstate = wxPyBeginAllowThreads();
52217 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52218 wxPyEndAllowThreads(__tstate);
52219 if (PyErr_Occurred()) SWIG_fail;
52220 }
52221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52222 return resultobj;
52223 fail:
52224 return NULL;
52225 }
52226
52227
52228 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52229 PyObject *resultobj = 0;
52230 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52231 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52232 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52233 bool result;
52234 void *argp1 = 0 ;
52235 int res1 = 0 ;
52236 void *argp2 = 0 ;
52237 int res2 = 0 ;
52238 void *argp3 = 0 ;
52239 int res3 = 0 ;
52240 PyObject * obj0 = 0 ;
52241 PyObject * obj1 = 0 ;
52242 PyObject * obj2 = 0 ;
52243 char * kwnames[] = {
52244 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52245 };
52246
52247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52249 if (!SWIG_IsOK(res1)) {
52250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52251 }
52252 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52253 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52254 if (!SWIG_IsOK(res2)) {
52255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52256 }
52257 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52258 if (obj2) {
52259 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52260 if (!SWIG_IsOK(res3)) {
52261 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52262 }
52263 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52264 }
52265 {
52266 PyThreadState* __tstate = wxPyBeginAllowThreads();
52267 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52268 wxPyEndAllowThreads(__tstate);
52269 if (PyErr_Occurred()) SWIG_fail;
52270 }
52271 {
52272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52273 }
52274 return resultobj;
52275 fail:
52276 return NULL;
52277 }
52278
52279
52280 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52281 PyObject *resultobj = 0;
52282 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52283 wxGBPosition *arg2 = 0 ;
52284 wxGBSpan *arg3 = 0 ;
52285 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52286 bool result;
52287 void *argp1 = 0 ;
52288 int res1 = 0 ;
52289 wxGBPosition temp2 ;
52290 wxGBSpan temp3 ;
52291 void *argp4 = 0 ;
52292 int res4 = 0 ;
52293 PyObject * obj0 = 0 ;
52294 PyObject * obj1 = 0 ;
52295 PyObject * obj2 = 0 ;
52296 PyObject * obj3 = 0 ;
52297 char * kwnames[] = {
52298 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52299 };
52300
52301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52303 if (!SWIG_IsOK(res1)) {
52304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52305 }
52306 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52307 {
52308 arg2 = &temp2;
52309 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52310 }
52311 {
52312 arg3 = &temp3;
52313 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52314 }
52315 if (obj3) {
52316 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52317 if (!SWIG_IsOK(res4)) {
52318 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52319 }
52320 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52321 }
52322 {
52323 PyThreadState* __tstate = wxPyBeginAllowThreads();
52324 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52325 wxPyEndAllowThreads(__tstate);
52326 if (PyErr_Occurred()) SWIG_fail;
52327 }
52328 {
52329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52330 }
52331 return resultobj;
52332 fail:
52333 return NULL;
52334 }
52335
52336
52337 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52338 PyObject *obj;
52339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52340 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52341 return SWIG_Py_Void();
52342 }
52343
52344 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52345 return SWIG_Python_InitShadowInstance(args);
52346 }
52347
52348 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52349 PyObject *resultobj = 0;
52350 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52351 wxRelationship arg2 ;
52352 wxWindow *arg3 = (wxWindow *) 0 ;
52353 wxEdge arg4 ;
52354 int arg5 = (int) 0 ;
52355 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52356 void *argp1 = 0 ;
52357 int res1 = 0 ;
52358 int val2 ;
52359 int ecode2 = 0 ;
52360 void *argp3 = 0 ;
52361 int res3 = 0 ;
52362 int val4 ;
52363 int ecode4 = 0 ;
52364 int val5 ;
52365 int ecode5 = 0 ;
52366 int val6 ;
52367 int ecode6 = 0 ;
52368 PyObject * obj0 = 0 ;
52369 PyObject * obj1 = 0 ;
52370 PyObject * obj2 = 0 ;
52371 PyObject * obj3 = 0 ;
52372 PyObject * obj4 = 0 ;
52373 PyObject * obj5 = 0 ;
52374 char * kwnames[] = {
52375 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52376 };
52377
52378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52380 if (!SWIG_IsOK(res1)) {
52381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52382 }
52383 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52384 ecode2 = SWIG_AsVal_int(obj1, &val2);
52385 if (!SWIG_IsOK(ecode2)) {
52386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52387 }
52388 arg2 = static_cast< wxRelationship >(val2);
52389 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52390 if (!SWIG_IsOK(res3)) {
52391 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52392 }
52393 arg3 = reinterpret_cast< wxWindow * >(argp3);
52394 ecode4 = SWIG_AsVal_int(obj3, &val4);
52395 if (!SWIG_IsOK(ecode4)) {
52396 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52397 }
52398 arg4 = static_cast< wxEdge >(val4);
52399 if (obj4) {
52400 ecode5 = SWIG_AsVal_int(obj4, &val5);
52401 if (!SWIG_IsOK(ecode5)) {
52402 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52403 }
52404 arg5 = static_cast< int >(val5);
52405 }
52406 if (obj5) {
52407 ecode6 = SWIG_AsVal_int(obj5, &val6);
52408 if (!SWIG_IsOK(ecode6)) {
52409 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52410 }
52411 arg6 = static_cast< int >(val6);
52412 }
52413 {
52414 PyThreadState* __tstate = wxPyBeginAllowThreads();
52415 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52416 wxPyEndAllowThreads(__tstate);
52417 if (PyErr_Occurred()) SWIG_fail;
52418 }
52419 resultobj = SWIG_Py_Void();
52420 return resultobj;
52421 fail:
52422 return NULL;
52423 }
52424
52425
52426 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52427 PyObject *resultobj = 0;
52428 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52429 wxWindow *arg2 = (wxWindow *) 0 ;
52430 int arg3 = (int) 0 ;
52431 void *argp1 = 0 ;
52432 int res1 = 0 ;
52433 void *argp2 = 0 ;
52434 int res2 = 0 ;
52435 int val3 ;
52436 int ecode3 = 0 ;
52437 PyObject * obj0 = 0 ;
52438 PyObject * obj1 = 0 ;
52439 PyObject * obj2 = 0 ;
52440 char * kwnames[] = {
52441 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52442 };
52443
52444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52446 if (!SWIG_IsOK(res1)) {
52447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52448 }
52449 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52450 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52451 if (!SWIG_IsOK(res2)) {
52452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52453 }
52454 arg2 = reinterpret_cast< wxWindow * >(argp2);
52455 if (obj2) {
52456 ecode3 = SWIG_AsVal_int(obj2, &val3);
52457 if (!SWIG_IsOK(ecode3)) {
52458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
52459 }
52460 arg3 = static_cast< int >(val3);
52461 }
52462 {
52463 PyThreadState* __tstate = wxPyBeginAllowThreads();
52464 (arg1)->LeftOf(arg2,arg3);
52465 wxPyEndAllowThreads(__tstate);
52466 if (PyErr_Occurred()) SWIG_fail;
52467 }
52468 resultobj = SWIG_Py_Void();
52469 return resultobj;
52470 fail:
52471 return NULL;
52472 }
52473
52474
52475 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52476 PyObject *resultobj = 0;
52477 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52478 wxWindow *arg2 = (wxWindow *) 0 ;
52479 int arg3 = (int) 0 ;
52480 void *argp1 = 0 ;
52481 int res1 = 0 ;
52482 void *argp2 = 0 ;
52483 int res2 = 0 ;
52484 int val3 ;
52485 int ecode3 = 0 ;
52486 PyObject * obj0 = 0 ;
52487 PyObject * obj1 = 0 ;
52488 PyObject * obj2 = 0 ;
52489 char * kwnames[] = {
52490 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52491 };
52492
52493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52495 if (!SWIG_IsOK(res1)) {
52496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52497 }
52498 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52499 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52500 if (!SWIG_IsOK(res2)) {
52501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52502 }
52503 arg2 = reinterpret_cast< wxWindow * >(argp2);
52504 if (obj2) {
52505 ecode3 = SWIG_AsVal_int(obj2, &val3);
52506 if (!SWIG_IsOK(ecode3)) {
52507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
52508 }
52509 arg3 = static_cast< int >(val3);
52510 }
52511 {
52512 PyThreadState* __tstate = wxPyBeginAllowThreads();
52513 (arg1)->RightOf(arg2,arg3);
52514 wxPyEndAllowThreads(__tstate);
52515 if (PyErr_Occurred()) SWIG_fail;
52516 }
52517 resultobj = SWIG_Py_Void();
52518 return resultobj;
52519 fail:
52520 return NULL;
52521 }
52522
52523
52524 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52525 PyObject *resultobj = 0;
52526 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52527 wxWindow *arg2 = (wxWindow *) 0 ;
52528 int arg3 = (int) 0 ;
52529 void *argp1 = 0 ;
52530 int res1 = 0 ;
52531 void *argp2 = 0 ;
52532 int res2 = 0 ;
52533 int val3 ;
52534 int ecode3 = 0 ;
52535 PyObject * obj0 = 0 ;
52536 PyObject * obj1 = 0 ;
52537 PyObject * obj2 = 0 ;
52538 char * kwnames[] = {
52539 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52540 };
52541
52542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52544 if (!SWIG_IsOK(res1)) {
52545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52546 }
52547 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52548 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52549 if (!SWIG_IsOK(res2)) {
52550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
52551 }
52552 arg2 = reinterpret_cast< wxWindow * >(argp2);
52553 if (obj2) {
52554 ecode3 = SWIG_AsVal_int(obj2, &val3);
52555 if (!SWIG_IsOK(ecode3)) {
52556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
52557 }
52558 arg3 = static_cast< int >(val3);
52559 }
52560 {
52561 PyThreadState* __tstate = wxPyBeginAllowThreads();
52562 (arg1)->Above(arg2,arg3);
52563 wxPyEndAllowThreads(__tstate);
52564 if (PyErr_Occurred()) SWIG_fail;
52565 }
52566 resultobj = SWIG_Py_Void();
52567 return resultobj;
52568 fail:
52569 return NULL;
52570 }
52571
52572
52573 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52574 PyObject *resultobj = 0;
52575 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52576 wxWindow *arg2 = (wxWindow *) 0 ;
52577 int arg3 = (int) 0 ;
52578 void *argp1 = 0 ;
52579 int res1 = 0 ;
52580 void *argp2 = 0 ;
52581 int res2 = 0 ;
52582 int val3 ;
52583 int ecode3 = 0 ;
52584 PyObject * obj0 = 0 ;
52585 PyObject * obj1 = 0 ;
52586 PyObject * obj2 = 0 ;
52587 char * kwnames[] = {
52588 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52589 };
52590
52591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52593 if (!SWIG_IsOK(res1)) {
52594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52595 }
52596 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52597 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52598 if (!SWIG_IsOK(res2)) {
52599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
52600 }
52601 arg2 = reinterpret_cast< wxWindow * >(argp2);
52602 if (obj2) {
52603 ecode3 = SWIG_AsVal_int(obj2, &val3);
52604 if (!SWIG_IsOK(ecode3)) {
52605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
52606 }
52607 arg3 = static_cast< int >(val3);
52608 }
52609 {
52610 PyThreadState* __tstate = wxPyBeginAllowThreads();
52611 (arg1)->Below(arg2,arg3);
52612 wxPyEndAllowThreads(__tstate);
52613 if (PyErr_Occurred()) SWIG_fail;
52614 }
52615 resultobj = SWIG_Py_Void();
52616 return resultobj;
52617 fail:
52618 return NULL;
52619 }
52620
52621
52622 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52623 PyObject *resultobj = 0;
52624 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52625 wxWindow *arg2 = (wxWindow *) 0 ;
52626 wxEdge arg3 ;
52627 int arg4 = (int) 0 ;
52628 void *argp1 = 0 ;
52629 int res1 = 0 ;
52630 void *argp2 = 0 ;
52631 int res2 = 0 ;
52632 int val3 ;
52633 int ecode3 = 0 ;
52634 int val4 ;
52635 int ecode4 = 0 ;
52636 PyObject * obj0 = 0 ;
52637 PyObject * obj1 = 0 ;
52638 PyObject * obj2 = 0 ;
52639 PyObject * obj3 = 0 ;
52640 char * kwnames[] = {
52641 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
52642 };
52643
52644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52646 if (!SWIG_IsOK(res1)) {
52647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52648 }
52649 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52650 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52651 if (!SWIG_IsOK(res2)) {
52652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
52653 }
52654 arg2 = reinterpret_cast< wxWindow * >(argp2);
52655 ecode3 = SWIG_AsVal_int(obj2, &val3);
52656 if (!SWIG_IsOK(ecode3)) {
52657 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
52658 }
52659 arg3 = static_cast< wxEdge >(val3);
52660 if (obj3) {
52661 ecode4 = SWIG_AsVal_int(obj3, &val4);
52662 if (!SWIG_IsOK(ecode4)) {
52663 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
52664 }
52665 arg4 = static_cast< int >(val4);
52666 }
52667 {
52668 PyThreadState* __tstate = wxPyBeginAllowThreads();
52669 (arg1)->SameAs(arg2,arg3,arg4);
52670 wxPyEndAllowThreads(__tstate);
52671 if (PyErr_Occurred()) SWIG_fail;
52672 }
52673 resultobj = SWIG_Py_Void();
52674 return resultobj;
52675 fail:
52676 return NULL;
52677 }
52678
52679
52680 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52681 PyObject *resultobj = 0;
52682 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52683 wxWindow *arg2 = (wxWindow *) 0 ;
52684 wxEdge arg3 ;
52685 int arg4 ;
52686 void *argp1 = 0 ;
52687 int res1 = 0 ;
52688 void *argp2 = 0 ;
52689 int res2 = 0 ;
52690 int val3 ;
52691 int ecode3 = 0 ;
52692 int val4 ;
52693 int ecode4 = 0 ;
52694 PyObject * obj0 = 0 ;
52695 PyObject * obj1 = 0 ;
52696 PyObject * obj2 = 0 ;
52697 PyObject * obj3 = 0 ;
52698 char * kwnames[] = {
52699 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52700 };
52701
52702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52704 if (!SWIG_IsOK(res1)) {
52705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52706 }
52707 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52708 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52709 if (!SWIG_IsOK(res2)) {
52710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52711 }
52712 arg2 = reinterpret_cast< wxWindow * >(argp2);
52713 ecode3 = SWIG_AsVal_int(obj2, &val3);
52714 if (!SWIG_IsOK(ecode3)) {
52715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52716 }
52717 arg3 = static_cast< wxEdge >(val3);
52718 ecode4 = SWIG_AsVal_int(obj3, &val4);
52719 if (!SWIG_IsOK(ecode4)) {
52720 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52721 }
52722 arg4 = static_cast< int >(val4);
52723 {
52724 PyThreadState* __tstate = wxPyBeginAllowThreads();
52725 (arg1)->PercentOf(arg2,arg3,arg4);
52726 wxPyEndAllowThreads(__tstate);
52727 if (PyErr_Occurred()) SWIG_fail;
52728 }
52729 resultobj = SWIG_Py_Void();
52730 return resultobj;
52731 fail:
52732 return NULL;
52733 }
52734
52735
52736 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52737 PyObject *resultobj = 0;
52738 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52739 int arg2 ;
52740 void *argp1 = 0 ;
52741 int res1 = 0 ;
52742 int val2 ;
52743 int ecode2 = 0 ;
52744 PyObject * obj0 = 0 ;
52745 PyObject * obj1 = 0 ;
52746 char * kwnames[] = {
52747 (char *) "self",(char *) "val", NULL
52748 };
52749
52750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52752 if (!SWIG_IsOK(res1)) {
52753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52754 }
52755 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52756 ecode2 = SWIG_AsVal_int(obj1, &val2);
52757 if (!SWIG_IsOK(ecode2)) {
52758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52759 }
52760 arg2 = static_cast< int >(val2);
52761 {
52762 PyThreadState* __tstate = wxPyBeginAllowThreads();
52763 (arg1)->Absolute(arg2);
52764 wxPyEndAllowThreads(__tstate);
52765 if (PyErr_Occurred()) SWIG_fail;
52766 }
52767 resultobj = SWIG_Py_Void();
52768 return resultobj;
52769 fail:
52770 return NULL;
52771 }
52772
52773
52774 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52775 PyObject *resultobj = 0;
52776 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52777 void *argp1 = 0 ;
52778 int res1 = 0 ;
52779 PyObject *swig_obj[1] ;
52780
52781 if (!args) SWIG_fail;
52782 swig_obj[0] = args;
52783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52784 if (!SWIG_IsOK(res1)) {
52785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52786 }
52787 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52788 {
52789 PyThreadState* __tstate = wxPyBeginAllowThreads();
52790 (arg1)->Unconstrained();
52791 wxPyEndAllowThreads(__tstate);
52792 if (PyErr_Occurred()) SWIG_fail;
52793 }
52794 resultobj = SWIG_Py_Void();
52795 return resultobj;
52796 fail:
52797 return NULL;
52798 }
52799
52800
52801 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52802 PyObject *resultobj = 0;
52803 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52804 void *argp1 = 0 ;
52805 int res1 = 0 ;
52806 PyObject *swig_obj[1] ;
52807
52808 if (!args) SWIG_fail;
52809 swig_obj[0] = args;
52810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52811 if (!SWIG_IsOK(res1)) {
52812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52813 }
52814 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52815 {
52816 PyThreadState* __tstate = wxPyBeginAllowThreads();
52817 (arg1)->AsIs();
52818 wxPyEndAllowThreads(__tstate);
52819 if (PyErr_Occurred()) SWIG_fail;
52820 }
52821 resultobj = SWIG_Py_Void();
52822 return resultobj;
52823 fail:
52824 return NULL;
52825 }
52826
52827
52828 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52829 PyObject *resultobj = 0;
52830 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52831 wxWindow *result = 0 ;
52832 void *argp1 = 0 ;
52833 int res1 = 0 ;
52834 PyObject *swig_obj[1] ;
52835
52836 if (!args) SWIG_fail;
52837 swig_obj[0] = args;
52838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52839 if (!SWIG_IsOK(res1)) {
52840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52841 }
52842 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52843 {
52844 PyThreadState* __tstate = wxPyBeginAllowThreads();
52845 result = (wxWindow *)(arg1)->GetOtherWindow();
52846 wxPyEndAllowThreads(__tstate);
52847 if (PyErr_Occurred()) SWIG_fail;
52848 }
52849 {
52850 resultobj = wxPyMake_wxObject(result, 0);
52851 }
52852 return resultobj;
52853 fail:
52854 return NULL;
52855 }
52856
52857
52858 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52859 PyObject *resultobj = 0;
52860 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52861 wxEdge result;
52862 void *argp1 = 0 ;
52863 int res1 = 0 ;
52864 PyObject *swig_obj[1] ;
52865
52866 if (!args) SWIG_fail;
52867 swig_obj[0] = args;
52868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52869 if (!SWIG_IsOK(res1)) {
52870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52871 }
52872 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52873 {
52874 PyThreadState* __tstate = wxPyBeginAllowThreads();
52875 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52876 wxPyEndAllowThreads(__tstate);
52877 if (PyErr_Occurred()) SWIG_fail;
52878 }
52879 resultobj = SWIG_From_int(static_cast< int >(result));
52880 return resultobj;
52881 fail:
52882 return NULL;
52883 }
52884
52885
52886 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52887 PyObject *resultobj = 0;
52888 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52889 wxEdge arg2 ;
52890 void *argp1 = 0 ;
52891 int res1 = 0 ;
52892 int val2 ;
52893 int ecode2 = 0 ;
52894 PyObject * obj0 = 0 ;
52895 PyObject * obj1 = 0 ;
52896 char * kwnames[] = {
52897 (char *) "self",(char *) "which", NULL
52898 };
52899
52900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52902 if (!SWIG_IsOK(res1)) {
52903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52904 }
52905 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52906 ecode2 = SWIG_AsVal_int(obj1, &val2);
52907 if (!SWIG_IsOK(ecode2)) {
52908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52909 }
52910 arg2 = static_cast< wxEdge >(val2);
52911 {
52912 PyThreadState* __tstate = wxPyBeginAllowThreads();
52913 (arg1)->SetEdge(arg2);
52914 wxPyEndAllowThreads(__tstate);
52915 if (PyErr_Occurred()) SWIG_fail;
52916 }
52917 resultobj = SWIG_Py_Void();
52918 return resultobj;
52919 fail:
52920 return NULL;
52921 }
52922
52923
52924 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52925 PyObject *resultobj = 0;
52926 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52927 int arg2 ;
52928 void *argp1 = 0 ;
52929 int res1 = 0 ;
52930 int val2 ;
52931 int ecode2 = 0 ;
52932 PyObject * obj0 = 0 ;
52933 PyObject * obj1 = 0 ;
52934 char * kwnames[] = {
52935 (char *) "self",(char *) "v", NULL
52936 };
52937
52938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52940 if (!SWIG_IsOK(res1)) {
52941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52942 }
52943 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52944 ecode2 = SWIG_AsVal_int(obj1, &val2);
52945 if (!SWIG_IsOK(ecode2)) {
52946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52947 }
52948 arg2 = static_cast< int >(val2);
52949 {
52950 PyThreadState* __tstate = wxPyBeginAllowThreads();
52951 (arg1)->SetValue(arg2);
52952 wxPyEndAllowThreads(__tstate);
52953 if (PyErr_Occurred()) SWIG_fail;
52954 }
52955 resultobj = SWIG_Py_Void();
52956 return resultobj;
52957 fail:
52958 return NULL;
52959 }
52960
52961
52962 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52963 PyObject *resultobj = 0;
52964 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52965 int result;
52966 void *argp1 = 0 ;
52967 int res1 = 0 ;
52968 PyObject *swig_obj[1] ;
52969
52970 if (!args) SWIG_fail;
52971 swig_obj[0] = args;
52972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52973 if (!SWIG_IsOK(res1)) {
52974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52975 }
52976 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52977 {
52978 PyThreadState* __tstate = wxPyBeginAllowThreads();
52979 result = (int)(arg1)->GetMargin();
52980 wxPyEndAllowThreads(__tstate);
52981 if (PyErr_Occurred()) SWIG_fail;
52982 }
52983 resultobj = SWIG_From_int(static_cast< int >(result));
52984 return resultobj;
52985 fail:
52986 return NULL;
52987 }
52988
52989
52990 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52991 PyObject *resultobj = 0;
52992 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52993 int arg2 ;
52994 void *argp1 = 0 ;
52995 int res1 = 0 ;
52996 int val2 ;
52997 int ecode2 = 0 ;
52998 PyObject * obj0 = 0 ;
52999 PyObject * obj1 = 0 ;
53000 char * kwnames[] = {
53001 (char *) "self",(char *) "m", NULL
53002 };
53003
53004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53006 if (!SWIG_IsOK(res1)) {
53007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53008 }
53009 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53010 ecode2 = SWIG_AsVal_int(obj1, &val2);
53011 if (!SWIG_IsOK(ecode2)) {
53012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53013 }
53014 arg2 = static_cast< int >(val2);
53015 {
53016 PyThreadState* __tstate = wxPyBeginAllowThreads();
53017 (arg1)->SetMargin(arg2);
53018 wxPyEndAllowThreads(__tstate);
53019 if (PyErr_Occurred()) SWIG_fail;
53020 }
53021 resultobj = SWIG_Py_Void();
53022 return resultobj;
53023 fail:
53024 return NULL;
53025 }
53026
53027
53028 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53029 PyObject *resultobj = 0;
53030 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53031 int result;
53032 void *argp1 = 0 ;
53033 int res1 = 0 ;
53034 PyObject *swig_obj[1] ;
53035
53036 if (!args) SWIG_fail;
53037 swig_obj[0] = args;
53038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53039 if (!SWIG_IsOK(res1)) {
53040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53041 }
53042 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53043 {
53044 PyThreadState* __tstate = wxPyBeginAllowThreads();
53045 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53046 wxPyEndAllowThreads(__tstate);
53047 if (PyErr_Occurred()) SWIG_fail;
53048 }
53049 resultobj = SWIG_From_int(static_cast< int >(result));
53050 return resultobj;
53051 fail:
53052 return NULL;
53053 }
53054
53055
53056 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53057 PyObject *resultobj = 0;
53058 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53059 int result;
53060 void *argp1 = 0 ;
53061 int res1 = 0 ;
53062 PyObject *swig_obj[1] ;
53063
53064 if (!args) SWIG_fail;
53065 swig_obj[0] = args;
53066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53067 if (!SWIG_IsOK(res1)) {
53068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53069 }
53070 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53071 {
53072 PyThreadState* __tstate = wxPyBeginAllowThreads();
53073 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53074 wxPyEndAllowThreads(__tstate);
53075 if (PyErr_Occurred()) SWIG_fail;
53076 }
53077 resultobj = SWIG_From_int(static_cast< int >(result));
53078 return resultobj;
53079 fail:
53080 return NULL;
53081 }
53082
53083
53084 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53085 PyObject *resultobj = 0;
53086 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53087 int result;
53088 void *argp1 = 0 ;
53089 int res1 = 0 ;
53090 PyObject *swig_obj[1] ;
53091
53092 if (!args) SWIG_fail;
53093 swig_obj[0] = args;
53094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53095 if (!SWIG_IsOK(res1)) {
53096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53097 }
53098 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53099 {
53100 PyThreadState* __tstate = wxPyBeginAllowThreads();
53101 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53102 wxPyEndAllowThreads(__tstate);
53103 if (PyErr_Occurred()) SWIG_fail;
53104 }
53105 resultobj = SWIG_From_int(static_cast< int >(result));
53106 return resultobj;
53107 fail:
53108 return NULL;
53109 }
53110
53111
53112 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53113 PyObject *resultobj = 0;
53114 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53115 bool result;
53116 void *argp1 = 0 ;
53117 int res1 = 0 ;
53118 PyObject *swig_obj[1] ;
53119
53120 if (!args) SWIG_fail;
53121 swig_obj[0] = args;
53122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53123 if (!SWIG_IsOK(res1)) {
53124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53125 }
53126 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53127 {
53128 PyThreadState* __tstate = wxPyBeginAllowThreads();
53129 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53130 wxPyEndAllowThreads(__tstate);
53131 if (PyErr_Occurred()) SWIG_fail;
53132 }
53133 {
53134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53135 }
53136 return resultobj;
53137 fail:
53138 return NULL;
53139 }
53140
53141
53142 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53143 PyObject *resultobj = 0;
53144 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53145 bool arg2 ;
53146 void *argp1 = 0 ;
53147 int res1 = 0 ;
53148 bool val2 ;
53149 int ecode2 = 0 ;
53150 PyObject * obj0 = 0 ;
53151 PyObject * obj1 = 0 ;
53152 char * kwnames[] = {
53153 (char *) "self",(char *) "d", NULL
53154 };
53155
53156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53158 if (!SWIG_IsOK(res1)) {
53159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53160 }
53161 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53162 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53163 if (!SWIG_IsOK(ecode2)) {
53164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53165 }
53166 arg2 = static_cast< bool >(val2);
53167 {
53168 PyThreadState* __tstate = wxPyBeginAllowThreads();
53169 (arg1)->SetDone(arg2);
53170 wxPyEndAllowThreads(__tstate);
53171 if (PyErr_Occurred()) SWIG_fail;
53172 }
53173 resultobj = SWIG_Py_Void();
53174 return resultobj;
53175 fail:
53176 return NULL;
53177 }
53178
53179
53180 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53181 PyObject *resultobj = 0;
53182 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53183 wxRelationship result;
53184 void *argp1 = 0 ;
53185 int res1 = 0 ;
53186 PyObject *swig_obj[1] ;
53187
53188 if (!args) SWIG_fail;
53189 swig_obj[0] = args;
53190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53191 if (!SWIG_IsOK(res1)) {
53192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53193 }
53194 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53195 {
53196 PyThreadState* __tstate = wxPyBeginAllowThreads();
53197 result = (wxRelationship)(arg1)->GetRelationship();
53198 wxPyEndAllowThreads(__tstate);
53199 if (PyErr_Occurred()) SWIG_fail;
53200 }
53201 resultobj = SWIG_From_int(static_cast< int >(result));
53202 return resultobj;
53203 fail:
53204 return NULL;
53205 }
53206
53207
53208 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53209 PyObject *resultobj = 0;
53210 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53211 wxRelationship arg2 ;
53212 void *argp1 = 0 ;
53213 int res1 = 0 ;
53214 int val2 ;
53215 int ecode2 = 0 ;
53216 PyObject * obj0 = 0 ;
53217 PyObject * obj1 = 0 ;
53218 char * kwnames[] = {
53219 (char *) "self",(char *) "r", NULL
53220 };
53221
53222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53224 if (!SWIG_IsOK(res1)) {
53225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53226 }
53227 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53228 ecode2 = SWIG_AsVal_int(obj1, &val2);
53229 if (!SWIG_IsOK(ecode2)) {
53230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53231 }
53232 arg2 = static_cast< wxRelationship >(val2);
53233 {
53234 PyThreadState* __tstate = wxPyBeginAllowThreads();
53235 (arg1)->SetRelationship(arg2);
53236 wxPyEndAllowThreads(__tstate);
53237 if (PyErr_Occurred()) SWIG_fail;
53238 }
53239 resultobj = SWIG_Py_Void();
53240 return resultobj;
53241 fail:
53242 return NULL;
53243 }
53244
53245
53246 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53247 PyObject *resultobj = 0;
53248 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53249 wxWindow *arg2 = (wxWindow *) 0 ;
53250 bool result;
53251 void *argp1 = 0 ;
53252 int res1 = 0 ;
53253 void *argp2 = 0 ;
53254 int res2 = 0 ;
53255 PyObject * obj0 = 0 ;
53256 PyObject * obj1 = 0 ;
53257 char * kwnames[] = {
53258 (char *) "self",(char *) "otherW", NULL
53259 };
53260
53261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53263 if (!SWIG_IsOK(res1)) {
53264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53265 }
53266 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53268 if (!SWIG_IsOK(res2)) {
53269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53270 }
53271 arg2 = reinterpret_cast< wxWindow * >(argp2);
53272 {
53273 PyThreadState* __tstate = wxPyBeginAllowThreads();
53274 result = (bool)(arg1)->ResetIfWin(arg2);
53275 wxPyEndAllowThreads(__tstate);
53276 if (PyErr_Occurred()) SWIG_fail;
53277 }
53278 {
53279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53280 }
53281 return resultobj;
53282 fail:
53283 return NULL;
53284 }
53285
53286
53287 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53288 PyObject *resultobj = 0;
53289 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53290 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53291 wxWindow *arg3 = (wxWindow *) 0 ;
53292 bool result;
53293 void *argp1 = 0 ;
53294 int res1 = 0 ;
53295 void *argp2 = 0 ;
53296 int res2 = 0 ;
53297 void *argp3 = 0 ;
53298 int res3 = 0 ;
53299 PyObject * obj0 = 0 ;
53300 PyObject * obj1 = 0 ;
53301 PyObject * obj2 = 0 ;
53302 char * kwnames[] = {
53303 (char *) "self",(char *) "constraints",(char *) "win", NULL
53304 };
53305
53306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53308 if (!SWIG_IsOK(res1)) {
53309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53310 }
53311 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53312 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53313 if (!SWIG_IsOK(res2)) {
53314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53315 }
53316 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53317 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53318 if (!SWIG_IsOK(res3)) {
53319 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53320 }
53321 arg3 = reinterpret_cast< wxWindow * >(argp3);
53322 {
53323 PyThreadState* __tstate = wxPyBeginAllowThreads();
53324 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53325 wxPyEndAllowThreads(__tstate);
53326 if (PyErr_Occurred()) SWIG_fail;
53327 }
53328 {
53329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53330 }
53331 return resultobj;
53332 fail:
53333 return NULL;
53334 }
53335
53336
53337 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53338 PyObject *resultobj = 0;
53339 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53340 wxEdge arg2 ;
53341 wxWindow *arg3 = (wxWindow *) 0 ;
53342 wxWindow *arg4 = (wxWindow *) 0 ;
53343 int result;
53344 void *argp1 = 0 ;
53345 int res1 = 0 ;
53346 int val2 ;
53347 int ecode2 = 0 ;
53348 void *argp3 = 0 ;
53349 int res3 = 0 ;
53350 void *argp4 = 0 ;
53351 int res4 = 0 ;
53352 PyObject * obj0 = 0 ;
53353 PyObject * obj1 = 0 ;
53354 PyObject * obj2 = 0 ;
53355 PyObject * obj3 = 0 ;
53356 char * kwnames[] = {
53357 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53358 };
53359
53360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53362 if (!SWIG_IsOK(res1)) {
53363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53364 }
53365 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53366 ecode2 = SWIG_AsVal_int(obj1, &val2);
53367 if (!SWIG_IsOK(ecode2)) {
53368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53369 }
53370 arg2 = static_cast< wxEdge >(val2);
53371 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53372 if (!SWIG_IsOK(res3)) {
53373 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53374 }
53375 arg3 = reinterpret_cast< wxWindow * >(argp3);
53376 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53377 if (!SWIG_IsOK(res4)) {
53378 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53379 }
53380 arg4 = reinterpret_cast< wxWindow * >(argp4);
53381 {
53382 PyThreadState* __tstate = wxPyBeginAllowThreads();
53383 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53384 wxPyEndAllowThreads(__tstate);
53385 if (PyErr_Occurred()) SWIG_fail;
53386 }
53387 resultobj = SWIG_From_int(static_cast< int >(result));
53388 return resultobj;
53389 fail:
53390 return NULL;
53391 }
53392
53393
53394 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53395 PyObject *obj;
53396 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53397 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53398 return SWIG_Py_Void();
53399 }
53400
53401 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53402 PyObject *resultobj = 0;
53403 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53404 wxIndividualLayoutConstraint *result = 0 ;
53405 void *argp1 = 0 ;
53406 int res1 = 0 ;
53407 PyObject *swig_obj[1] ;
53408
53409 if (!args) SWIG_fail;
53410 swig_obj[0] = args;
53411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53412 if (!SWIG_IsOK(res1)) {
53413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53414 }
53415 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53416 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53418 return resultobj;
53419 fail:
53420 return NULL;
53421 }
53422
53423
53424 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53425 PyObject *resultobj = 0;
53426 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53427 wxIndividualLayoutConstraint *result = 0 ;
53428 void *argp1 = 0 ;
53429 int res1 = 0 ;
53430 PyObject *swig_obj[1] ;
53431
53432 if (!args) SWIG_fail;
53433 swig_obj[0] = args;
53434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53435 if (!SWIG_IsOK(res1)) {
53436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53437 }
53438 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53439 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
53440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53441 return resultobj;
53442 fail:
53443 return NULL;
53444 }
53445
53446
53447 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53448 PyObject *resultobj = 0;
53449 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53450 wxIndividualLayoutConstraint *result = 0 ;
53451 void *argp1 = 0 ;
53452 int res1 = 0 ;
53453 PyObject *swig_obj[1] ;
53454
53455 if (!args) SWIG_fail;
53456 swig_obj[0] = args;
53457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53458 if (!SWIG_IsOK(res1)) {
53459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53460 }
53461 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53462 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
53463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53464 return resultobj;
53465 fail:
53466 return NULL;
53467 }
53468
53469
53470 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53471 PyObject *resultobj = 0;
53472 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53473 wxIndividualLayoutConstraint *result = 0 ;
53474 void *argp1 = 0 ;
53475 int res1 = 0 ;
53476 PyObject *swig_obj[1] ;
53477
53478 if (!args) SWIG_fail;
53479 swig_obj[0] = args;
53480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53481 if (!SWIG_IsOK(res1)) {
53482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53483 }
53484 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53485 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
53486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53487 return resultobj;
53488 fail:
53489 return NULL;
53490 }
53491
53492
53493 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53494 PyObject *resultobj = 0;
53495 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53496 wxIndividualLayoutConstraint *result = 0 ;
53497 void *argp1 = 0 ;
53498 int res1 = 0 ;
53499 PyObject *swig_obj[1] ;
53500
53501 if (!args) SWIG_fail;
53502 swig_obj[0] = args;
53503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53504 if (!SWIG_IsOK(res1)) {
53505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53506 }
53507 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53508 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
53509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53510 return resultobj;
53511 fail:
53512 return NULL;
53513 }
53514
53515
53516 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53517 PyObject *resultobj = 0;
53518 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53519 wxIndividualLayoutConstraint *result = 0 ;
53520 void *argp1 = 0 ;
53521 int res1 = 0 ;
53522 PyObject *swig_obj[1] ;
53523
53524 if (!args) SWIG_fail;
53525 swig_obj[0] = args;
53526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53527 if (!SWIG_IsOK(res1)) {
53528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53529 }
53530 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53531 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
53532 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53533 return resultobj;
53534 fail:
53535 return NULL;
53536 }
53537
53538
53539 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53540 PyObject *resultobj = 0;
53541 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53542 wxIndividualLayoutConstraint *result = 0 ;
53543 void *argp1 = 0 ;
53544 int res1 = 0 ;
53545 PyObject *swig_obj[1] ;
53546
53547 if (!args) SWIG_fail;
53548 swig_obj[0] = args;
53549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53550 if (!SWIG_IsOK(res1)) {
53551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53552 }
53553 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53554 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
53555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53556 return resultobj;
53557 fail:
53558 return NULL;
53559 }
53560
53561
53562 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53563 PyObject *resultobj = 0;
53564 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53565 wxIndividualLayoutConstraint *result = 0 ;
53566 void *argp1 = 0 ;
53567 int res1 = 0 ;
53568 PyObject *swig_obj[1] ;
53569
53570 if (!args) SWIG_fail;
53571 swig_obj[0] = args;
53572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53573 if (!SWIG_IsOK(res1)) {
53574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53575 }
53576 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53577 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
53578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53579 return resultobj;
53580 fail:
53581 return NULL;
53582 }
53583
53584
53585 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53586 PyObject *resultobj = 0;
53587 wxLayoutConstraints *result = 0 ;
53588
53589 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
53590 {
53591 PyThreadState* __tstate = wxPyBeginAllowThreads();
53592 result = (wxLayoutConstraints *)new wxLayoutConstraints();
53593 wxPyEndAllowThreads(__tstate);
53594 if (PyErr_Occurred()) SWIG_fail;
53595 }
53596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
53597 return resultobj;
53598 fail:
53599 return NULL;
53600 }
53601
53602
53603 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53604 PyObject *resultobj = 0;
53605 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53606 void *argp1 = 0 ;
53607 int res1 = 0 ;
53608 PyObject *swig_obj[1] ;
53609
53610 if (!args) SWIG_fail;
53611 swig_obj[0] = args;
53612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
53613 if (!SWIG_IsOK(res1)) {
53614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53615 }
53616 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53617 {
53618 PyThreadState* __tstate = wxPyBeginAllowThreads();
53619 delete arg1;
53620
53621 wxPyEndAllowThreads(__tstate);
53622 if (PyErr_Occurred()) SWIG_fail;
53623 }
53624 resultobj = SWIG_Py_Void();
53625 return resultobj;
53626 fail:
53627 return NULL;
53628 }
53629
53630
53631 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53632 PyObject *resultobj = 0;
53633 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53634 wxWindow *arg2 = (wxWindow *) 0 ;
53635 int *arg3 = (int *) 0 ;
53636 bool result;
53637 void *argp1 = 0 ;
53638 int res1 = 0 ;
53639 void *argp2 = 0 ;
53640 int res2 = 0 ;
53641 int temp3 ;
53642 int res3 = SWIG_TMPOBJ ;
53643 PyObject * obj0 = 0 ;
53644 PyObject * obj1 = 0 ;
53645 char * kwnames[] = {
53646 (char *) "self",(char *) "win", NULL
53647 };
53648
53649 arg3 = &temp3;
53650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
53651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53652 if (!SWIG_IsOK(res1)) {
53653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53654 }
53655 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53656 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53657 if (!SWIG_IsOK(res2)) {
53658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
53659 }
53660 arg2 = reinterpret_cast< wxWindow * >(argp2);
53661 {
53662 PyThreadState* __tstate = wxPyBeginAllowThreads();
53663 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
53664 wxPyEndAllowThreads(__tstate);
53665 if (PyErr_Occurred()) SWIG_fail;
53666 }
53667 {
53668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53669 }
53670 if (SWIG_IsTmpObj(res3)) {
53671 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53672 } else {
53673 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53674 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53675 }
53676 return resultobj;
53677 fail:
53678 return NULL;
53679 }
53680
53681
53682 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53683 PyObject *resultobj = 0;
53684 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53685 bool result;
53686 void *argp1 = 0 ;
53687 int res1 = 0 ;
53688 PyObject *swig_obj[1] ;
53689
53690 if (!args) SWIG_fail;
53691 swig_obj[0] = args;
53692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53693 if (!SWIG_IsOK(res1)) {
53694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53695 }
53696 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53697 {
53698 PyThreadState* __tstate = wxPyBeginAllowThreads();
53699 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53700 wxPyEndAllowThreads(__tstate);
53701 if (PyErr_Occurred()) SWIG_fail;
53702 }
53703 {
53704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53705 }
53706 return resultobj;
53707 fail:
53708 return NULL;
53709 }
53710
53711
53712 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53713 PyObject *obj;
53714 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53715 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53716 return SWIG_Py_Void();
53717 }
53718
53719 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53720 return SWIG_Python_InitShadowInstance(args);
53721 }
53722
53723 static PyMethodDef SwigMethods[] = {
53724 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53725 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53726 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53727 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53728 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53729 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53730 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53731 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53732 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53734 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53745 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53746 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53747 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53749 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53750 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53751 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53752 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53753 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53754 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53755 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53757 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53763 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53764 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53765 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53766 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53767 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53768 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53769 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53771 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53779 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53780 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53781 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53786 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53787 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53789 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53791 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53793 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53795 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53797 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53799 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53800 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53802 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53804 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53805 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53806 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53807 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53827 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53828 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53829 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53830 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53831 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53832 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53833 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53834 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53836 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53837 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53838 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53843 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53844 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53845 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53846 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53853 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53860 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53861 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53862 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53863 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53865 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53866 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53867 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53869 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53870 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53871 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53872 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53877 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53878 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53879 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53880 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53881 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53882 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53885 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53886 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53887 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53889 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53890 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53891 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53892 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53893 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
53894 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53895 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53896 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53897 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53898 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53899 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53900 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53901 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53902 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53903 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53908 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53914 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53915 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53916 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53917 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53919 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53922 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53925 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53928 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53929 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53930 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53933 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53934 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53935 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53939 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53940 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53941 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53945 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53950 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53951 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53952 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53953 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53954 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53955 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53956 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53963 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53964 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53966 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53967 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53968 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53974 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53975 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53977 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53978 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53979 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53980 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53981 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53982 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53983 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53984 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53986 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53987 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53988 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53989 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53990 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53991 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53992 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53993 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53995 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54004 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54016 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54017 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54021 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
54032 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54033 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54034 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54035 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54038 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54040 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54042 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54044 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54046 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54047 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54049 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54050 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54051 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54052 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54054 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54060 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54071 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54072 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54078 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54079 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54081 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54082 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54083 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54084 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54085 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54086 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54087 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54088 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54089 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54090 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54091 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54092 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54093 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54094 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54095 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54096 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54097 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54098 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54099 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54100 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54101 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54102 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54103 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54104 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54105 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54106 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54107 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54108 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54109 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54110 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54111 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54112 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54113 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54114 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54115 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54116 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54117 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54118 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54120 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54121 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54124 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54125 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54126 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54129 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54130 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54131 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54132 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54134 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54135 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54137 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54139 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54141 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54143 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54144 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54145 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54147 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54148 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54150 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54151 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54152 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54154 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54155 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54156 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54158 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54160 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54161 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54162 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54164 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54166 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54167 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54169 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54170 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54171 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54173 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54174 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54175 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54176 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54177 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54178 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54179 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54180 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54183 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54184 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54186 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54187 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54190 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54191 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54192 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54193 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54199 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54200 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54201 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54202 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54203 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54204 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54205 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54206 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54207 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54208 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54209 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54210 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54211 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54212 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54213 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54214 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54215 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54216 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54217 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54218 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54219 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54220 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54221 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54222 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54224 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54225 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54226 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54227 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54228 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54229 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54230 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54231 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54232 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54233 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54234 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54235 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54236 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54237 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54238 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54239 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54240 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54241 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54242 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54243 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54244 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54245 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54246 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54247 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54248 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54249 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54250 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54251 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54252 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54253 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54254 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54255 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54256 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54257 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54258 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54259 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54260 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54261 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54262 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54263 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54264 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54265 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54266 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54267 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54268 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54269 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54270 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54271 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54272 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54273 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54274 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54275 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54276 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54277 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54278 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54279 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54280 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54281 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54282 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54283 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54284 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54285 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54286 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54287 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54288 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54289 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54290 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54291 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54292 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54293 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54294 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54295 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54296 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54297 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54298 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54299 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54300 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54301 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54302 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54303 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54304 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54305 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54306 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54307 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54308 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54309 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54310 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54311 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54312 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54313 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54314 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54315 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54316 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54317 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54318 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54319 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54320 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54321 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54322 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54323 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54324 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54325 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54326 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54327 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54328 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54329 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54330 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54331 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54332 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54333 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54334 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54335 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54336 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54337 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54338 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54339 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54341 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54342 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54343 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54344 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54345 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54346 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54347 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54348 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54349 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54350 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54351 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54352 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54353 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54354 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54355 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54357 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54358 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54359 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54360 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54361 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54362 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54363 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54364 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54365 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54366 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54367 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54368 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54369 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54370 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54371 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54372 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54373 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54374 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54375 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54376 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54377 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54378 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54379 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54380 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54381 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54382 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54383 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54384 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54385 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54386 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54387 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54389 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54390 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54392 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54394 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54395 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54396 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54397 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54398 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54399 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54400 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54401 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54402 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54403 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54404 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54405 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54406 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54407 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54408 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54409 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54410 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54411 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54412 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54413 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54414 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54415 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54416 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54417 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54418 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54419 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54420 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54421 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
54422 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
54423 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54424 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
54425 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
54427 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
54428 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
54429 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
54430 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
54431 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
54432 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
54433 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54434 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
54435 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
54436 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
54437 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54438 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
54439 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
54440 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
54441 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54442 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
54443 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
54445 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
54446 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
54447 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
54448 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
54449 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54450 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
54451 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
54453 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
54454 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54455 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
54456 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
54457 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54458 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
54459 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
54461 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
54462 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
54463 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54464 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
54465 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54466 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
54467 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
54468 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
54469 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54470 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
54471 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
54472 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
54473 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
54474 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
54475 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
54476 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
54478 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
54480 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
54481 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
54482 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
54483 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
54484 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
54485 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
54487 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
54488 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
54489 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
54490 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
54491 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
54492 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
54493 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
54494 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
54495 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
54496 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
54497 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54498 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
54499 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
54500 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
54501 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
54502 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
54503 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
54504 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
54505 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
54506 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
54507 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
54508 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
54509 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
54510 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
54511 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
54512 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
54513 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54514 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54515 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54516 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
54517 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
54518 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
54519 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
54520 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
54521 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
54522 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
54523 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
54524 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
54525 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
54526 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
54527 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54528 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
54529 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
54530 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
54531 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
54532 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
54533 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
54534 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
54535 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
54536 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
54537 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
54538 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
54539 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
54540 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
54541 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
54542 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
54543 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
54544 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
54545 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
54546 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
54547 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
54548 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
54549 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54550 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54551 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
54552 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
54553 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
54554 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
54555 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
54556 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
54557 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
54558 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
54559 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54560 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
54561 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
54562 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
54563 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
54564 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
54565 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
54566 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
54567 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
54568 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
54569 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
54570 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
54571 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
54572 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
54573 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
54574 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
54575 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
54576 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
54577 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54578 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
54579 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
54580 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
54581 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
54582 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54583 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
54584 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54585 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
54586 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
54587 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
54588 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54589 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
54590 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
54591 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54592 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54593 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
54594 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54595 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54596 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54597 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
54598 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54599 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54600 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
54601 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
54603 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
54604 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
54605 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
54606 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54607 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
54608 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
54609 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
54610 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
54611 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
54612 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
54613 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
54614 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
54615 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
54616 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
54617 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
54618 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
54619 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
54620 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
54621 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
54622 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
54623 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
54624 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
54625 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
54626 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
54627 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
54628 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
54629 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
54630 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54631 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54632 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54633 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54634 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
54635 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
54636 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54637 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
54638 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
54639 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
54640 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
54641 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
54642 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
54643 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54644 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
54645 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
54646 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
54647 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54648 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
54649 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54650 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
54651 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
54652 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
54653 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
54654 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54655 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
54656 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54657 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
54658 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54659 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
54660 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
54661 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54662 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
54663 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
54664 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
54665 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
54666 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
54667 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
54668 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
54669 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54670 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54671 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
54672 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
54673 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
54674 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
54675 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
54676 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54677 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54678 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54679 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54680 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54681 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54682 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54683 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54684 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54685 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54686 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54687 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54688 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54689 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54690 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54691 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54692 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54693 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54694 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54695 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54696 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54697 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54698 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54699 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54700 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54701 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54702 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54703 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54704 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54705 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54706 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54707 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54708 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54709 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54710 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54711 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54712 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
54713 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54714 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54715 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54716 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54717 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54718 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54719 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54720 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54721 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54722 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54723 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54724 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54725 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54726 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54727 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54728 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54729 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54730 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54731 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54732 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54733 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54734 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54735 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54736 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54737 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54738 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54739 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54740 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54741 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54742 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54743 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54744 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54745 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54746 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54747 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54748 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54749 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54750 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54751 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54752 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54753 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54754 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54755 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54756 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54757 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54758 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54759 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54760 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54761 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54762 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54763 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54764 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54765 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54766 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54767 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54768 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54769 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54770 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54771 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54772 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54773 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54774 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54775 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54776 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54777 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54778 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54779 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54780 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54781 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54782 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54783 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54784 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54785 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54786 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54787 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54788 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54789 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54790 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54791 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54792 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54793 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54794 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54795 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54796 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54797 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54798 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54799 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54800 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54801 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54802 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54803 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54804 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54805 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54806 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54807 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54808 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54809 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54810 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54811 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54812 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54813 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54814 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54815 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54816 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54817 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54818 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54819 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54820 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54821 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54822 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54823 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54824 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54825 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54826 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54827 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54828 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54829 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54830 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54831 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54832 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54833 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54834 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54835 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54836 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54837 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54838 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54839 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54840 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54841 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54842 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54843 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54844 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54845 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54846 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54847 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54848 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54849 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54850 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54851 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54852 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54853 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54854 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54855 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54856 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54857 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54858 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54859 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54860 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54861 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54862 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54863 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54864 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54865 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54866 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54867 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54868 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54869 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54870 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54871 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54872 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54873 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54874 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54875 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54876 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54877 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54878 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54879 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54880 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54881 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54882 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54883 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54884 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54885 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54886 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54887 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54888 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54889 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54890 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54891 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54892 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54893 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54894 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54895 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54896 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54897 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54898 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54899 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54900 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54901 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54902 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54903 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54904 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54905 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54906 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54907 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54908 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54909 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54910 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54911 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54912 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54913 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54914 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54915 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54916 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54917 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54918 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54919 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54920 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54921 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54922 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54923 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54924 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54925 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54926 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54927 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54928 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54929 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54930 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54931 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54932 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54933 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54934 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54935 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54936 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54937 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54938 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54939 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54940 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54941 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54942 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54943 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54944 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54945 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54946 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54947 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54948 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54949 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54950 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54951 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54952 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54953 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54954 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54955 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54956 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54957 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54958 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54959 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54960 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54961 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54962 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54963 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54964 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54965 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54966 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54967 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54968 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54969 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54970 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54971 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54972 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54973 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54974 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54975 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54976 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54977 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54978 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54979 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54980 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54981 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54982 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54983 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54984 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54985 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54986 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54987 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54988 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54989 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54990 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54991 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54992 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54993 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54994 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54995 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54996 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54997 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54998 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54999 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55000 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55001 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55002 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55003 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55004 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55005 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55006 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55007 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55008 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55009 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55010 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55011 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55012 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55013 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55014 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55015 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55016 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55017 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55018 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55019 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55020 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55021 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55022 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55023 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55024 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55025 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55026 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55027 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55028 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55029 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55030 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55031 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55032 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55033 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55034 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55035 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55036 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55037 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55038 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55039 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55040 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55041 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55042 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55043 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55044 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55045 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55046 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55047 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55048 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55049 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55050 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55051 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55052 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55053 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55054 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55055 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55056 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55057 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55058 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55059 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55060 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55061 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55062 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55063 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55064 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55065 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55066 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55067 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55068 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55069 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55070 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55071 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55072 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55073 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55074 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55075 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55076 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55077 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55078 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55079 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55080 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55081 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55082 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55083 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55084 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55085 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55086 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55087 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55088 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55089 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55090 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55091 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55092 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55093 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55094 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55095 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55096 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55097 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55098 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55099 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55100 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55101 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55102 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55103 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55104 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55105 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55106 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55107 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55108 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55109 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55110 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55111 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55112 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55113 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55114 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55115 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55116 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55117 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55118 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55119 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55120 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55121 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55122 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55123 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55124 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55125 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55126 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55127 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55128 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55129 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55130 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55131 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55132 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55133 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55134 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55135 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55136 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55137 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55138 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55139 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55140 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55141 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55142 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55143 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55144 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55145 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55146 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55147 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55148 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55149 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55150 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55151 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55152 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55153 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55154 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55155 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55156 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55157 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55158 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55159 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55160 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55161 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55162 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55163 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55164 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55165 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55166 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55167 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55168 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55169 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55170 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55171 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55172 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55173 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55174 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55175 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55176 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55177 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55178 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55179 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55180 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55181 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55182 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55183 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55184 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55185 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55186 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55187 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55188 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55189 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55190 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55191 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55192 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55193 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55194 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55195 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55196 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55197 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55198 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55199 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55200 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55201 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55202 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55203 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55204 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55205 { NULL, NULL, 0, NULL }
55206 };
55207
55208
55209 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55210
55211 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55212 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55213 }
55214 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55215 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55216 }
55217 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55218 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55219 }
55220 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55221 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55222 }
55223 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55224 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55225 }
55226 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55227 return (void *)((wxSizer *) ((wxGridSizer *) x));
55228 }
55229 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55230 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55231 }
55232 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55233 return (void *)((wxSizer *) ((wxPySizer *) x));
55234 }
55235 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55236 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55237 }
55238 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55239 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55240 }
55241 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55242 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55243 }
55244 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55245 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55246 }
55247 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55248 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55249 }
55250 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55251 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55252 }
55253 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55254 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55255 }
55256 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55257 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55258 }
55259 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55260 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55261 }
55262 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55263 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55264 }
55265 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55266 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55267 }
55268 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55269 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55270 }
55271 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55272 return (void *)((wxEvent *) ((wxPyEvent *) x));
55273 }
55274 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55275 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55276 }
55277 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55278 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55279 }
55280 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55281 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55282 }
55283 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55284 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55285 }
55286 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55287 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55288 }
55289 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55290 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55291 }
55292 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55293 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55294 }
55295 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55296 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55297 }
55298 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55299 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55300 }
55301 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55302 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55303 }
55304 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55305 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55306 }
55307 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55308 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55309 }
55310 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55311 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55312 }
55313 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55314 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55315 }
55316 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55317 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55318 }
55319 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55320 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55321 }
55322 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55323 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55324 }
55325 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55326 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55327 }
55328 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55329 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55330 }
55331 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55332 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55333 }
55334 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55335 return (void *)((wxEvent *) ((wxShowEvent *) x));
55336 }
55337 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55338 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55339 }
55340 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55341 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55342 }
55343 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55344 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55345 }
55346 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55347 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55348 }
55349 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55350 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55351 }
55352 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55353 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55354 }
55355 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55356 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55357 }
55358 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55359 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55360 }
55361 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55362 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55363 }
55364 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55365 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55366 }
55367 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55368 return (void *)((wxControl *) ((wxControlWithItems *) x));
55369 }
55370 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55371 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55372 }
55373 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55374 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55375 }
55376 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55377 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55378 }
55379 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55380 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55381 }
55382 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55383 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55384 }
55385 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55386 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55387 }
55388 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55389 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55390 }
55391 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55392 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55393 }
55394 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55395 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55396 }
55397 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55398 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55399 }
55400 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55401 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55402 }
55403 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55404 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55405 }
55406 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55407 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55408 }
55409 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55410 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55411 }
55412 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55413 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55414 }
55415 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55416 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55417 }
55418 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55419 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55420 }
55421 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
55422 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55423 }
55424 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
55425 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55426 }
55427 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
55428 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
55429 }
55430 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
55431 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
55432 }
55433 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
55434 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
55435 }
55436 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
55437 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
55438 }
55439 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
55440 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
55441 }
55442 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
55443 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
55444 }
55445 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
55446 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
55447 }
55448 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
55449 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
55450 }
55451 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
55452 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
55453 }
55454 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
55455 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
55456 }
55457 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
55458 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
55459 }
55460 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
55461 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
55462 }
55463 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
55464 return (void *)((wxObject *) ((wxSizerItem *) x));
55465 }
55466 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
55467 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
55468 }
55469 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
55470 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
55471 }
55472 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
55473 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
55474 }
55475 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
55476 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
55477 }
55478 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
55479 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
55480 }
55481 static void *_p_wxSizerTo_p_wxObject(void *x) {
55482 return (void *)((wxObject *) ((wxSizer *) x));
55483 }
55484 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
55485 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55486 }
55487 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
55488 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
55489 }
55490 static void *_p_wxEventTo_p_wxObject(void *x) {
55491 return (void *)((wxObject *) ((wxEvent *) x));
55492 }
55493 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
55494 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
55495 }
55496 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
55497 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
55498 }
55499 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
55500 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
55501 }
55502 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
55503 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
55504 }
55505 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
55506 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
55507 }
55508 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
55509 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
55510 }
55511 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
55512 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
55513 }
55514 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
55515 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
55516 }
55517 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
55518 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55519 }
55520 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
55521 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
55522 }
55523 static void *_p_wxControlTo_p_wxObject(void *x) {
55524 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
55525 }
55526 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
55527 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
55528 }
55529 static void *_p_wxFSFileTo_p_wxObject(void *x) {
55530 return (void *)((wxObject *) ((wxFSFile *) x));
55531 }
55532 static void *_p_wxPySizerTo_p_wxObject(void *x) {
55533 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
55534 }
55535 static void *_p_wxPyEventTo_p_wxObject(void *x) {
55536 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
55537 }
55538 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
55539 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
55540 }
55541 static void *_p_wxShowEventTo_p_wxObject(void *x) {
55542 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
55543 }
55544 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
55545 return (void *)((wxObject *) ((wxMenuItem *) x));
55546 }
55547 static void *_p_wxDateEventTo_p_wxObject(void *x) {
55548 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
55549 }
55550 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
55551 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
55552 }
55553 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
55554 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
55555 }
55556 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
55557 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
55558 }
55559 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
55560 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
55561 }
55562 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
55563 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
55564 }
55565 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
55566 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
55567 }
55568 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
55569 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
55570 }
55571 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
55572 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
55573 }
55574 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
55575 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
55576 }
55577 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
55578 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
55579 }
55580 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
55581 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
55582 }
55583 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
55584 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
55585 }
55586 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
55587 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
55588 }
55589 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
55590 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55591 }
55592 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
55593 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55594 }
55595 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
55596 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
55597 }
55598 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
55599 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
55600 }
55601 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
55602 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
55603 }
55604 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
55605 return (void *)((wxObject *) ((wxImageHandler *) x));
55606 }
55607 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
55608 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
55609 }
55610 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
55611 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
55612 }
55613 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
55614 return (void *)((wxObject *) ((wxEvtHandler *) x));
55615 }
55616 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
55617 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
55618 }
55619 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
55620 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55621 }
55622 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
55623 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
55624 }
55625 static void *_p_wxImageTo_p_wxObject(void *x) {
55626 return (void *)((wxObject *) ((wxImage *) x));
55627 }
55628 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
55629 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
55630 }
55631 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
55632 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55633 }
55634 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
55635 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
55636 }
55637 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
55638 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
55639 }
55640 static void *_p_wxWindowTo_p_wxObject(void *x) {
55641 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
55642 }
55643 static void *_p_wxMenuTo_p_wxObject(void *x) {
55644 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
55645 }
55646 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
55647 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
55648 }
55649 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
55650 return (void *)((wxObject *) ((wxFileSystem *) x));
55651 }
55652 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
55653 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
55654 }
55655 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
55656 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
55657 }
55658 static void *_p_wxPyAppTo_p_wxObject(void *x) {
55659 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
55660 }
55661 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
55662 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
55663 }
55664 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
55665 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
55666 }
55667 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
55668 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
55669 }
55670 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
55671 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
55672 }
55673 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
55674 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
55675 }
55676 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
55677 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
55678 }
55679 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
55680 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
55681 }
55682 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55683 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55684 }
55685 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55686 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55687 }
55688 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55689 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55690 }
55691 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55692 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55693 }
55694 static void *_p_wxControlTo_p_wxWindow(void *x) {
55695 return (void *)((wxWindow *) ((wxControl *) x));
55696 }
55697 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55698 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55699 }
55700 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55701 return (void *)((wxWindow *) ((wxMenuBar *) x));
55702 }
55703 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55704 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55705 }
55706 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55707 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55708 }
55709 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55710 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55711 }
55712 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55713 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55714 }
55715 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55716 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55717 }
55718 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55719 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55720 }
55721 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55722 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55723 }
55724 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55725 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55726 }
55727 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55728 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55729 }
55730 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55731 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55732 }
55733 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55734 return (void *)((wxValidator *) ((wxPyValidator *) x));
55735 }
55736 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55737 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55738 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};
55739 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55740 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55741 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55742 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55743 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55744 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55745 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55746 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55747 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55748 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55749 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55750 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55751 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55752 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55753 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55754 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55755 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55756 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55757 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55758 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55759 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55760 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55761 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55762 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55763 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55764 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55765 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55766 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55767 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55768 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55769 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55770 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55771 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55772 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55773 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55774 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55775 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55776 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55777 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55778 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55779 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55780 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55781 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55782 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55783 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55784 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55785 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55786 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55787 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55788 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55789 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55790 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55791 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55792 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55793 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55794 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55795 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55796 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55797 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55798 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55799 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55800 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55801 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55802 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55803 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55804 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55805 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55806 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55807 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55808 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55809 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55810 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55811 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55812 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55813 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55814 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55815 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55816 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55817 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55818 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55819 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55820 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55821 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55822 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55823 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55824 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55825 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55826 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55827 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55828 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55829 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55830 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55831 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55832 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55833 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55834 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55835 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55836 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55837 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55838 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55839 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55840 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55841 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55842 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55843 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55844 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55845 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55846 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55847 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55848 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55849 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55850 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55851 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55852 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55853 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55854 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55855 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55856 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55857 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55858 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55859 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55860 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55861 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55862 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55863 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55864 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55865 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55866 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55867 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55868
55869 static swig_type_info *swig_type_initial[] = {
55870 &_swigt__p_buffer,
55871 &_swigt__p_char,
55872 &_swigt__p_form_ops_t,
55873 &_swigt__p_int,
55874 &_swigt__p_long,
55875 &_swigt__p_unsigned_char,
55876 &_swigt__p_unsigned_int,
55877 &_swigt__p_unsigned_long,
55878 &_swigt__p_wxANIHandler,
55879 &_swigt__p_wxAcceleratorEntry,
55880 &_swigt__p_wxAcceleratorTable,
55881 &_swigt__p_wxActivateEvent,
55882 &_swigt__p_wxAppTraits,
55883 &_swigt__p_wxArrayString,
55884 &_swigt__p_wxBMPHandler,
55885 &_swigt__p_wxBitmap,
55886 &_swigt__p_wxBoxSizer,
55887 &_swigt__p_wxButton,
55888 &_swigt__p_wxCURHandler,
55889 &_swigt__p_wxCaret,
55890 &_swigt__p_wxChildFocusEvent,
55891 &_swigt__p_wxClipboardTextEvent,
55892 &_swigt__p_wxCloseEvent,
55893 &_swigt__p_wxColour,
55894 &_swigt__p_wxCommandEvent,
55895 &_swigt__p_wxContextMenuEvent,
55896 &_swigt__p_wxControl,
55897 &_swigt__p_wxControlWithItems,
55898 &_swigt__p_wxCursor,
55899 &_swigt__p_wxDC,
55900 &_swigt__p_wxDateEvent,
55901 &_swigt__p_wxDateTime,
55902 &_swigt__p_wxDisplayChangedEvent,
55903 &_swigt__p_wxDropFilesEvent,
55904 &_swigt__p_wxDuplexMode,
55905 &_swigt__p_wxEraseEvent,
55906 &_swigt__p_wxEvent,
55907 &_swigt__p_wxEventLoop,
55908 &_swigt__p_wxEventLoopActivator,
55909 &_swigt__p_wxEvtHandler,
55910 &_swigt__p_wxFSFile,
55911 &_swigt__p_wxFileSystem,
55912 &_swigt__p_wxFileSystemHandler,
55913 &_swigt__p_wxFlexGridSizer,
55914 &_swigt__p_wxFocusEvent,
55915 &_swigt__p_wxFont,
55916 &_swigt__p_wxFrame,
55917 &_swigt__p_wxGBPosition,
55918 &_swigt__p_wxGBSizerItem,
55919 &_swigt__p_wxGBSpan,
55920 &_swigt__p_wxGIFHandler,
55921 &_swigt__p_wxGridBagSizer,
55922 &_swigt__p_wxGridSizer,
55923 &_swigt__p_wxHelpEvent__Origin,
55924 &_swigt__p_wxICOHandler,
55925 &_swigt__p_wxIconizeEvent,
55926 &_swigt__p_wxIdleEvent,
55927 &_swigt__p_wxImage,
55928 &_swigt__p_wxImageHandler,
55929 &_swigt__p_wxImageHistogram,
55930 &_swigt__p_wxImage_HSVValue,
55931 &_swigt__p_wxImage_RGBValue,
55932 &_swigt__p_wxIndividualLayoutConstraint,
55933 &_swigt__p_wxInitDialogEvent,
55934 &_swigt__p_wxInputStream,
55935 &_swigt__p_wxInternetFSHandler,
55936 &_swigt__p_wxItemContainer,
55937 &_swigt__p_wxJPEGHandler,
55938 &_swigt__p_wxKeyEvent,
55939 &_swigt__p_wxLayoutConstraints,
55940 &_swigt__p_wxMaximizeEvent,
55941 &_swigt__p_wxMemoryFSHandler,
55942 &_swigt__p_wxMenu,
55943 &_swigt__p_wxMenuBar,
55944 &_swigt__p_wxMenuBarBase,
55945 &_swigt__p_wxMenuEvent,
55946 &_swigt__p_wxMenuItem,
55947 &_swigt__p_wxMouseCaptureChangedEvent,
55948 &_swigt__p_wxMouseCaptureLostEvent,
55949 &_swigt__p_wxMouseEvent,
55950 &_swigt__p_wxMoveEvent,
55951 &_swigt__p_wxNavigationKeyEvent,
55952 &_swigt__p_wxNcPaintEvent,
55953 &_swigt__p_wxNotifyEvent,
55954 &_swigt__p_wxObject,
55955 &_swigt__p_wxOutputStream,
55956 &_swigt__p_wxPCXHandler,
55957 &_swigt__p_wxPNGHandler,
55958 &_swigt__p_wxPNMHandler,
55959 &_swigt__p_wxPaintEvent,
55960 &_swigt__p_wxPaletteChangedEvent,
55961 &_swigt__p_wxPaperSize,
55962 &_swigt__p_wxPoint,
55963 &_swigt__p_wxPoint2D,
55964 &_swigt__p_wxPropagateOnce,
55965 &_swigt__p_wxPropagationDisabler,
55966 &_swigt__p_wxPyApp,
55967 &_swigt__p_wxPyCommandEvent,
55968 &_swigt__p_wxPyDropTarget,
55969 &_swigt__p_wxPyEvent,
55970 &_swigt__p_wxPyFileSystemHandler,
55971 &_swigt__p_wxPyImageHandler,
55972 &_swigt__p_wxPyInputStream,
55973 &_swigt__p_wxPySizer,
55974 &_swigt__p_wxPyValidator,
55975 &_swigt__p_wxQuantize,
55976 &_swigt__p_wxQueryNewPaletteEvent,
55977 &_swigt__p_wxRealPoint,
55978 &_swigt__p_wxRect,
55979 &_swigt__p_wxRegion,
55980 &_swigt__p_wxScrollEvent,
55981 &_swigt__p_wxScrollWinEvent,
55982 &_swigt__p_wxSetCursorEvent,
55983 &_swigt__p_wxShowEvent,
55984 &_swigt__p_wxSize,
55985 &_swigt__p_wxSizeEvent,
55986 &_swigt__p_wxSizer,
55987 &_swigt__p_wxSizerItem,
55988 &_swigt__p_wxStaticBox,
55989 &_swigt__p_wxStaticBoxSizer,
55990 &_swigt__p_wxStdDialogButtonSizer,
55991 &_swigt__p_wxSysColourChangedEvent,
55992 &_swigt__p_wxTIFFHandler,
55993 &_swigt__p_wxToolTip,
55994 &_swigt__p_wxUpdateUIEvent,
55995 &_swigt__p_wxValidator,
55996 &_swigt__p_wxVisualAttributes,
55997 &_swigt__p_wxWindow,
55998 &_swigt__p_wxWindowCreateEvent,
55999 &_swigt__p_wxWindowDestroyEvent,
56000 &_swigt__p_wxXPMHandler,
56001 &_swigt__p_wxZipFSHandler,
56002 };
56003
56004 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56005 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56006 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56007 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56008 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56009 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56010 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56011 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56012 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56013 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56014 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56015 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56016 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56017 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56018 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}};
56019 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56020 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}};
56021 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56022 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}};
56023 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56024 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56025 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56026 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56027 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56028 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}};
56029 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56030 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}};
56031 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56032 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56033 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56034 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56035 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56036 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56037 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56038 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56039 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56040 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
56041 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56042 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56043 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}};
56044 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56045 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56046 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}};
56047 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}};
56048 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56049 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56050 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56051 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56052 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56053 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56054 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56055 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56056 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}};
56057 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56058 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}};
56059 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56060 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56061 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56062 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}};
56063 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56064 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56065 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56066 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56067 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56068 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56069 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56070 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}};
56071 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56072 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56073 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56074 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56075 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56076 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56077 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56078 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56079 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56080 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56081 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56082 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56083 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56084 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56085 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56086 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56087 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56088 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
56089 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56090 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56091 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56092 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56093 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56094 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56095 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56096 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56097 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56098 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56099 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56100 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56101 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56102 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56103 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56104 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56105 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56106 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56107 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56108 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56109 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56110 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56111 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56112 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56113 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56114 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56115 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56116 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56117 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56118 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56119 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56120 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}};
56121 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}};
56122 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56123 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56124 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56125 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56126 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56127 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56128 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56129 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}};
56130 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56131 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}};
56132 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56133 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56134 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56135 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56136
56137 static swig_cast_info *swig_cast_initial[] = {
56138 _swigc__p_buffer,
56139 _swigc__p_char,
56140 _swigc__p_form_ops_t,
56141 _swigc__p_int,
56142 _swigc__p_long,
56143 _swigc__p_unsigned_char,
56144 _swigc__p_unsigned_int,
56145 _swigc__p_unsigned_long,
56146 _swigc__p_wxANIHandler,
56147 _swigc__p_wxAcceleratorEntry,
56148 _swigc__p_wxAcceleratorTable,
56149 _swigc__p_wxActivateEvent,
56150 _swigc__p_wxAppTraits,
56151 _swigc__p_wxArrayString,
56152 _swigc__p_wxBMPHandler,
56153 _swigc__p_wxBitmap,
56154 _swigc__p_wxBoxSizer,
56155 _swigc__p_wxButton,
56156 _swigc__p_wxCURHandler,
56157 _swigc__p_wxCaret,
56158 _swigc__p_wxChildFocusEvent,
56159 _swigc__p_wxClipboardTextEvent,
56160 _swigc__p_wxCloseEvent,
56161 _swigc__p_wxColour,
56162 _swigc__p_wxCommandEvent,
56163 _swigc__p_wxContextMenuEvent,
56164 _swigc__p_wxControl,
56165 _swigc__p_wxControlWithItems,
56166 _swigc__p_wxCursor,
56167 _swigc__p_wxDC,
56168 _swigc__p_wxDateEvent,
56169 _swigc__p_wxDateTime,
56170 _swigc__p_wxDisplayChangedEvent,
56171 _swigc__p_wxDropFilesEvent,
56172 _swigc__p_wxDuplexMode,
56173 _swigc__p_wxEraseEvent,
56174 _swigc__p_wxEvent,
56175 _swigc__p_wxEventLoop,
56176 _swigc__p_wxEventLoopActivator,
56177 _swigc__p_wxEvtHandler,
56178 _swigc__p_wxFSFile,
56179 _swigc__p_wxFileSystem,
56180 _swigc__p_wxFileSystemHandler,
56181 _swigc__p_wxFlexGridSizer,
56182 _swigc__p_wxFocusEvent,
56183 _swigc__p_wxFont,
56184 _swigc__p_wxFrame,
56185 _swigc__p_wxGBPosition,
56186 _swigc__p_wxGBSizerItem,
56187 _swigc__p_wxGBSpan,
56188 _swigc__p_wxGIFHandler,
56189 _swigc__p_wxGridBagSizer,
56190 _swigc__p_wxGridSizer,
56191 _swigc__p_wxHelpEvent__Origin,
56192 _swigc__p_wxICOHandler,
56193 _swigc__p_wxIconizeEvent,
56194 _swigc__p_wxIdleEvent,
56195 _swigc__p_wxImage,
56196 _swigc__p_wxImageHandler,
56197 _swigc__p_wxImageHistogram,
56198 _swigc__p_wxImage_HSVValue,
56199 _swigc__p_wxImage_RGBValue,
56200 _swigc__p_wxIndividualLayoutConstraint,
56201 _swigc__p_wxInitDialogEvent,
56202 _swigc__p_wxInputStream,
56203 _swigc__p_wxInternetFSHandler,
56204 _swigc__p_wxItemContainer,
56205 _swigc__p_wxJPEGHandler,
56206 _swigc__p_wxKeyEvent,
56207 _swigc__p_wxLayoutConstraints,
56208 _swigc__p_wxMaximizeEvent,
56209 _swigc__p_wxMemoryFSHandler,
56210 _swigc__p_wxMenu,
56211 _swigc__p_wxMenuBar,
56212 _swigc__p_wxMenuBarBase,
56213 _swigc__p_wxMenuEvent,
56214 _swigc__p_wxMenuItem,
56215 _swigc__p_wxMouseCaptureChangedEvent,
56216 _swigc__p_wxMouseCaptureLostEvent,
56217 _swigc__p_wxMouseEvent,
56218 _swigc__p_wxMoveEvent,
56219 _swigc__p_wxNavigationKeyEvent,
56220 _swigc__p_wxNcPaintEvent,
56221 _swigc__p_wxNotifyEvent,
56222 _swigc__p_wxObject,
56223 _swigc__p_wxOutputStream,
56224 _swigc__p_wxPCXHandler,
56225 _swigc__p_wxPNGHandler,
56226 _swigc__p_wxPNMHandler,
56227 _swigc__p_wxPaintEvent,
56228 _swigc__p_wxPaletteChangedEvent,
56229 _swigc__p_wxPaperSize,
56230 _swigc__p_wxPoint,
56231 _swigc__p_wxPoint2D,
56232 _swigc__p_wxPropagateOnce,
56233 _swigc__p_wxPropagationDisabler,
56234 _swigc__p_wxPyApp,
56235 _swigc__p_wxPyCommandEvent,
56236 _swigc__p_wxPyDropTarget,
56237 _swigc__p_wxPyEvent,
56238 _swigc__p_wxPyFileSystemHandler,
56239 _swigc__p_wxPyImageHandler,
56240 _swigc__p_wxPyInputStream,
56241 _swigc__p_wxPySizer,
56242 _swigc__p_wxPyValidator,
56243 _swigc__p_wxQuantize,
56244 _swigc__p_wxQueryNewPaletteEvent,
56245 _swigc__p_wxRealPoint,
56246 _swigc__p_wxRect,
56247 _swigc__p_wxRegion,
56248 _swigc__p_wxScrollEvent,
56249 _swigc__p_wxScrollWinEvent,
56250 _swigc__p_wxSetCursorEvent,
56251 _swigc__p_wxShowEvent,
56252 _swigc__p_wxSize,
56253 _swigc__p_wxSizeEvent,
56254 _swigc__p_wxSizer,
56255 _swigc__p_wxSizerItem,
56256 _swigc__p_wxStaticBox,
56257 _swigc__p_wxStaticBoxSizer,
56258 _swigc__p_wxStdDialogButtonSizer,
56259 _swigc__p_wxSysColourChangedEvent,
56260 _swigc__p_wxTIFFHandler,
56261 _swigc__p_wxToolTip,
56262 _swigc__p_wxUpdateUIEvent,
56263 _swigc__p_wxValidator,
56264 _swigc__p_wxVisualAttributes,
56265 _swigc__p_wxWindow,
56266 _swigc__p_wxWindowCreateEvent,
56267 _swigc__p_wxWindowDestroyEvent,
56268 _swigc__p_wxXPMHandler,
56269 _swigc__p_wxZipFSHandler,
56270 };
56271
56272
56273 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56274
56275 static swig_const_info swig_const_table[] = {
56276 {0, 0, 0, 0.0, 0, 0}};
56277
56278 #ifdef __cplusplus
56279 }
56280 #endif
56281 /* -----------------------------------------------------------------------------
56282 * Type initialization:
56283 * This problem is tough by the requirement that no dynamic
56284 * memory is used. Also, since swig_type_info structures store pointers to
56285 * swig_cast_info structures and swig_cast_info structures store pointers back
56286 * to swig_type_info structures, we need some lookup code at initialization.
56287 * The idea is that swig generates all the structures that are needed.
56288 * The runtime then collects these partially filled structures.
56289 * The SWIG_InitializeModule function takes these initial arrays out of
56290 * swig_module, and does all the lookup, filling in the swig_module.types
56291 * array with the correct data and linking the correct swig_cast_info
56292 * structures together.
56293 *
56294 * The generated swig_type_info structures are assigned staticly to an initial
56295 * array. We just loop though that array, and handle each type individually.
56296 * First we lookup if this type has been already loaded, and if so, use the
56297 * loaded structure instead of the generated one. Then we have to fill in the
56298 * cast linked list. The cast data is initially stored in something like a
56299 * two-dimensional array. Each row corresponds to a type (there are the same
56300 * number of rows as there are in the swig_type_initial array). Each entry in
56301 * a column is one of the swig_cast_info structures for that type.
56302 * The cast_initial array is actually an array of arrays, because each row has
56303 * a variable number of columns. So to actually build the cast linked list,
56304 * we find the array of casts associated with the type, and loop through it
56305 * adding the casts to the list. The one last trick we need to do is making
56306 * sure the type pointer in the swig_cast_info struct is correct.
56307 *
56308 * First off, we lookup the cast->type name to see if it is already loaded.
56309 * There are three cases to handle:
56310 * 1) If the cast->type has already been loaded AND the type we are adding
56311 * casting info to has not been loaded (it is in this module), THEN we
56312 * replace the cast->type pointer with the type pointer that has already
56313 * been loaded.
56314 * 2) If BOTH types (the one we are adding casting info to, and the
56315 * cast->type) are loaded, THEN the cast info has already been loaded by
56316 * the previous module so we just ignore it.
56317 * 3) Finally, if cast->type has not already been loaded, then we add that
56318 * swig_cast_info to the linked list (because the cast->type) pointer will
56319 * be correct.
56320 * ----------------------------------------------------------------------------- */
56321
56322 #ifdef __cplusplus
56323 extern "C" {
56324 #if 0
56325 } /* c-mode */
56326 #endif
56327 #endif
56328
56329 #if 0
56330 #define SWIGRUNTIME_DEBUG
56331 #endif
56332
56333 SWIGRUNTIME void
56334 SWIG_InitializeModule(void *clientdata) {
56335 size_t i;
56336 swig_module_info *module_head;
56337 static int init_run = 0;
56338
56339 clientdata = clientdata;
56340
56341 if (init_run) return;
56342 init_run = 1;
56343
56344 /* Initialize the swig_module */
56345 swig_module.type_initial = swig_type_initial;
56346 swig_module.cast_initial = swig_cast_initial;
56347
56348 /* Try and load any already created modules */
56349 module_head = SWIG_GetModule(clientdata);
56350 if (module_head) {
56351 swig_module.next = module_head->next;
56352 module_head->next = &swig_module;
56353 } else {
56354 /* This is the first module loaded */
56355 swig_module.next = &swig_module;
56356 SWIG_SetModule(clientdata, &swig_module);
56357 }
56358
56359 /* Now work on filling in swig_module.types */
56360 #ifdef SWIGRUNTIME_DEBUG
56361 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56362 #endif
56363 for (i = 0; i < swig_module.size; ++i) {
56364 swig_type_info *type = 0;
56365 swig_type_info *ret;
56366 swig_cast_info *cast;
56367
56368 #ifdef SWIGRUNTIME_DEBUG
56369 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56370 #endif
56371
56372 /* if there is another module already loaded */
56373 if (swig_module.next != &swig_module) {
56374 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56375 }
56376 if (type) {
56377 /* Overwrite clientdata field */
56378 #ifdef SWIGRUNTIME_DEBUG
56379 printf("SWIG_InitializeModule: found type %s\n", type->name);
56380 #endif
56381 if (swig_module.type_initial[i]->clientdata) {
56382 type->clientdata = swig_module.type_initial[i]->clientdata;
56383 #ifdef SWIGRUNTIME_DEBUG
56384 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56385 #endif
56386 }
56387 } else {
56388 type = swig_module.type_initial[i];
56389 }
56390
56391 /* Insert casting types */
56392 cast = swig_module.cast_initial[i];
56393 while (cast->type) {
56394 /* Don't need to add information already in the list */
56395 ret = 0;
56396 #ifdef SWIGRUNTIME_DEBUG
56397 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56398 #endif
56399 if (swig_module.next != &swig_module) {
56400 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56401 #ifdef SWIGRUNTIME_DEBUG
56402 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56403 #endif
56404 }
56405 if (ret) {
56406 if (type == swig_module.type_initial[i]) {
56407 #ifdef SWIGRUNTIME_DEBUG
56408 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56409 #endif
56410 cast->type = ret;
56411 ret = 0;
56412 } else {
56413 /* Check for casting already in the list */
56414 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56415 #ifdef SWIGRUNTIME_DEBUG
56416 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56417 #endif
56418 if (!ocast) ret = 0;
56419 }
56420 }
56421
56422 if (!ret) {
56423 #ifdef SWIGRUNTIME_DEBUG
56424 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
56425 #endif
56426 if (type->cast) {
56427 type->cast->prev = cast;
56428 cast->next = type->cast;
56429 }
56430 type->cast = cast;
56431 }
56432 cast++;
56433 }
56434 /* Set entry in modules->types array equal to the type */
56435 swig_module.types[i] = type;
56436 }
56437 swig_module.types[i] = 0;
56438
56439 #ifdef SWIGRUNTIME_DEBUG
56440 printf("**** SWIG_InitializeModule: Cast List ******\n");
56441 for (i = 0; i < swig_module.size; ++i) {
56442 int j = 0;
56443 swig_cast_info *cast = swig_module.cast_initial[i];
56444 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56445 while (cast->type) {
56446 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
56447 cast++;
56448 ++j;
56449 }
56450 printf("---- Total casts: %d\n",j);
56451 }
56452 printf("**** SWIG_InitializeModule: Cast List ******\n");
56453 #endif
56454 }
56455
56456 /* This function will propagate the clientdata field of type to
56457 * any new swig_type_info structures that have been added into the list
56458 * of equivalent types. It is like calling
56459 * SWIG_TypeClientData(type, clientdata) a second time.
56460 */
56461 SWIGRUNTIME void
56462 SWIG_PropagateClientData(void) {
56463 size_t i;
56464 swig_cast_info *equiv;
56465 static int init_run = 0;
56466
56467 if (init_run) return;
56468 init_run = 1;
56469
56470 for (i = 0; i < swig_module.size; i++) {
56471 if (swig_module.types[i]->clientdata) {
56472 equiv = swig_module.types[i]->cast;
56473 while (equiv) {
56474 if (!equiv->converter) {
56475 if (equiv->type && !equiv->type->clientdata)
56476 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
56477 }
56478 equiv = equiv->next;
56479 }
56480 }
56481 }
56482 }
56483
56484 #ifdef __cplusplus
56485 #if 0
56486 {
56487 /* c-mode */
56488 #endif
56489 }
56490 #endif
56491
56492
56493
56494 #ifdef __cplusplus
56495 extern "C" {
56496 #endif
56497
56498 /* Python-specific SWIG API */
56499 #define SWIG_newvarlink() SWIG_Python_newvarlink()
56500 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
56501 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
56502
56503 /* -----------------------------------------------------------------------------
56504 * global variable support code.
56505 * ----------------------------------------------------------------------------- */
56506
56507 typedef struct swig_globalvar {
56508 char *name; /* Name of global variable */
56509 PyObject *(*get_attr)(void); /* Return the current value */
56510 int (*set_attr)(PyObject *); /* Set the value */
56511 struct swig_globalvar *next;
56512 } swig_globalvar;
56513
56514 typedef struct swig_varlinkobject {
56515 PyObject_HEAD
56516 swig_globalvar *vars;
56517 } swig_varlinkobject;
56518
56519 SWIGINTERN PyObject *
56520 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
56521 return PyString_FromString("<Swig global variables>");
56522 }
56523
56524 SWIGINTERN PyObject *
56525 swig_varlink_str(swig_varlinkobject *v) {
56526 PyObject *str = PyString_FromString("(");
56527 swig_globalvar *var;
56528 for (var = v->vars; var; var=var->next) {
56529 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
56530 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
56531 }
56532 PyString_ConcatAndDel(&str,PyString_FromString(")"));
56533 return str;
56534 }
56535
56536 SWIGINTERN int
56537 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
56538 PyObject *str = swig_varlink_str(v);
56539 fprintf(fp,"Swig global variables ");
56540 fprintf(fp,"%s\n", PyString_AsString(str));
56541 Py_DECREF(str);
56542 return 0;
56543 }
56544
56545 SWIGINTERN void
56546 swig_varlink_dealloc(swig_varlinkobject *v) {
56547 swig_globalvar *var = v->vars;
56548 while (var) {
56549 swig_globalvar *n = var->next;
56550 free(var->name);
56551 free(var);
56552 var = n;
56553 }
56554 }
56555
56556 SWIGINTERN PyObject *
56557 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
56558 PyObject *res = NULL;
56559 swig_globalvar *var = v->vars;
56560 while (var) {
56561 if (strcmp(var->name,n) == 0) {
56562 res = (*var->get_attr)();
56563 break;
56564 }
56565 var = var->next;
56566 }
56567 if (res == NULL && !PyErr_Occurred()) {
56568 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56569 }
56570 return res;
56571 }
56572
56573 SWIGINTERN int
56574 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
56575 int res = 1;
56576 swig_globalvar *var = v->vars;
56577 while (var) {
56578 if (strcmp(var->name,n) == 0) {
56579 res = (*var->set_attr)(p);
56580 break;
56581 }
56582 var = var->next;
56583 }
56584 if (res == 1 && !PyErr_Occurred()) {
56585 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56586 }
56587 return res;
56588 }
56589
56590 SWIGINTERN PyTypeObject*
56591 swig_varlink_type(void) {
56592 static char varlink__doc__[] = "Swig var link object";
56593 static PyTypeObject varlink_type;
56594 static int type_init = 0;
56595 if (!type_init) {
56596 const PyTypeObject tmp
56597 = {
56598 PyObject_HEAD_INIT(NULL)
56599 0, /* Number of items in variable part (ob_size) */
56600 (char *)"swigvarlink", /* Type name (tp_name) */
56601 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
56602 0, /* Itemsize (tp_itemsize) */
56603 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
56604 (printfunc) swig_varlink_print, /* Print (tp_print) */
56605 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
56606 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
56607 0, /* tp_compare */
56608 (reprfunc) swig_varlink_repr, /* tp_repr */
56609 0, /* tp_as_number */
56610 0, /* tp_as_sequence */
56611 0, /* tp_as_mapping */
56612 0, /* tp_hash */
56613 0, /* tp_call */
56614 (reprfunc)swig_varlink_str, /* tp_str */
56615 0, /* tp_getattro */
56616 0, /* tp_setattro */
56617 0, /* tp_as_buffer */
56618 0, /* tp_flags */
56619 varlink__doc__, /* tp_doc */
56620 0, /* tp_traverse */
56621 0, /* tp_clear */
56622 0, /* tp_richcompare */
56623 0, /* tp_weaklistoffset */
56624 #if PY_VERSION_HEX >= 0x02020000
56625 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
56626 #endif
56627 #if PY_VERSION_HEX >= 0x02030000
56628 0, /* tp_del */
56629 #endif
56630 #ifdef COUNT_ALLOCS
56631 0,0,0,0 /* tp_alloc -> tp_next */
56632 #endif
56633 };
56634 varlink_type = tmp;
56635 varlink_type.ob_type = &PyType_Type;
56636 type_init = 1;
56637 }
56638 return &varlink_type;
56639 }
56640
56641 /* Create a variable linking object for use later */
56642 SWIGINTERN PyObject *
56643 SWIG_Python_newvarlink(void) {
56644 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
56645 if (result) {
56646 result->vars = 0;
56647 }
56648 return ((PyObject*) result);
56649 }
56650
56651 SWIGINTERN void
56652 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
56653 swig_varlinkobject *v = (swig_varlinkobject *) p;
56654 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
56655 if (gv) {
56656 size_t size = strlen(name)+1;
56657 gv->name = (char *)malloc(size);
56658 if (gv->name) {
56659 strncpy(gv->name,name,size);
56660 gv->get_attr = get_attr;
56661 gv->set_attr = set_attr;
56662 gv->next = v->vars;
56663 }
56664 }
56665 v->vars = gv;
56666 }
56667
56668 SWIGINTERN PyObject *
56669 SWIG_globals() {
56670 static PyObject *_SWIG_globals = 0;
56671 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
56672 return _SWIG_globals;
56673 }
56674
56675 /* -----------------------------------------------------------------------------
56676 * constants/methods manipulation
56677 * ----------------------------------------------------------------------------- */
56678
56679 /* Install Constants */
56680 SWIGINTERN void
56681 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
56682 PyObject *obj = 0;
56683 size_t i;
56684 for (i = 0; constants[i].type; ++i) {
56685 switch(constants[i].type) {
56686 case SWIG_PY_POINTER:
56687 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56688 break;
56689 case SWIG_PY_BINARY:
56690 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56691 break;
56692 default:
56693 obj = 0;
56694 break;
56695 }
56696 if (obj) {
56697 PyDict_SetItemString(d, constants[i].name, obj);
56698 Py_DECREF(obj);
56699 }
56700 }
56701 }
56702
56703 /* -----------------------------------------------------------------------------*/
56704 /* Fix SwigMethods to carry the callback ptrs when needed */
56705 /* -----------------------------------------------------------------------------*/
56706
56707 SWIGINTERN void
56708 SWIG_Python_FixMethods(PyMethodDef *methods,
56709 swig_const_info *const_table,
56710 swig_type_info **types,
56711 swig_type_info **types_initial) {
56712 size_t i;
56713 for (i = 0; methods[i].ml_name; ++i) {
56714 const char *c = methods[i].ml_doc;
56715 if (c && (c = strstr(c, "swig_ptr: "))) {
56716 int j;
56717 swig_const_info *ci = 0;
56718 const char *name = c + 10;
56719 for (j = 0; const_table[j].type; ++j) {
56720 if (strncmp(const_table[j].name, name,
56721 strlen(const_table[j].name)) == 0) {
56722 ci = &(const_table[j]);
56723 break;
56724 }
56725 }
56726 if (ci) {
56727 size_t shift = (ci->ptype) - types;
56728 swig_type_info *ty = types_initial[shift];
56729 size_t ldoc = (c - methods[i].ml_doc);
56730 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56731 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56732 if (ndoc) {
56733 char *buff = ndoc;
56734 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56735 if (ptr) {
56736 strncpy(buff, methods[i].ml_doc, ldoc);
56737 buff += ldoc;
56738 strncpy(buff, "swig_ptr: ", 10);
56739 buff += 10;
56740 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56741 methods[i].ml_doc = ndoc;
56742 }
56743 }
56744 }
56745 }
56746 }
56747 }
56748
56749 #ifdef __cplusplus
56750 }
56751 #endif
56752
56753 /* -----------------------------------------------------------------------------*
56754 * Partial Init method
56755 * -----------------------------------------------------------------------------*/
56756
56757 #ifdef __cplusplus
56758 extern "C"
56759 #endif
56760 SWIGEXPORT void SWIG_init(void) {
56761 PyObject *m, *d;
56762
56763 /* Fix SwigMethods to carry the callback ptrs when needed */
56764 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56765
56766 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56767 d = PyModule_GetDict(m);
56768
56769 SWIG_InitializeModule(0);
56770 SWIG_InstallConstants(d,swig_const_table);
56771
56772
56773
56774 #ifndef wxPyUSE_EXPORT
56775 // Make our API structure a CObject so other modules can import it
56776 // from this module.
56777 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56778 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56779 Py_XDECREF(cobj);
56780 #endif
56781
56782 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56783 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56784 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56785 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56786 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56787 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56788 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56789 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56790 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56791 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56792 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56793 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56794 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56795 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56796 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56797 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56798 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56799 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56800 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56801 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56802 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56803 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56804 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56805 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56806 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56807 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56808 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56809 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56810 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56811 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56812 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56813 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56814 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56815 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56816 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56817 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56818 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56819 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56820 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56821 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56822 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56823 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56824 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56825 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56826 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56827 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56828 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56829 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56830 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56831 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56832 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56833 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56834 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56835 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56836 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56837 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56838 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56839 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56840 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56841 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56842 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56843 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56844 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56845 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56846 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56847 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56848 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56849 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56850 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56851 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56852 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56853 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56854 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56855 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56856 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56857 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56858 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56859 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56860 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56861 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56862 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56863 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56864 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56865 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56866 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56867 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56868 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56869 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56870 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56871 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56872 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56873 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56874 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56875 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56876 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56877 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56878 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56879 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56880 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56881 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56882 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56883 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56884 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56885 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56886 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56887 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56888 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56889 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56890 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56891 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56892 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56893 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56894 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56895 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56896 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56897 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56898 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56899 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56900 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56901 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56902 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56903 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56904 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56905 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56906 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56907 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
56908 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56909 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56910 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56911 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56912 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56913 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56914 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56915 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56916 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56917 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56918 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56919 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56920 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56921 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56922 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56923 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56924 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56925 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56926 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56927 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
56928 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56929 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56930 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56931 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56932 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56933 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56934 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56935 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56936 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56937 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56938 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56939 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56940 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56941 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56942 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56943 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56944 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56945 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56946 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56947 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56948 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56949 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56950 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56951 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56952 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56953 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56954 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56955 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56956 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56957 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56958 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56959 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56960 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56961 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56962 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56963 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56964 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56965 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56966 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56967 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56968 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56969 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56970 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56971 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56972 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56973 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56974 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56975 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56976 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56977 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56978 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56979 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56980 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56981 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56982 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56983 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56984 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56985 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56986 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56987 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56988 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56989 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56990 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56991 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56992 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56993 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56994 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56995 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56996 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56997 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56998 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56999 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57000 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57001 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57002 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57003 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57004 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57005 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57006 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57007 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57008 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57009 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57010 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57011 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57012 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57013 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57014 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57015 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57016 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57017 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57018 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57019 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57020 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57021 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57022 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57023 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57024 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57025 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57026 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57027 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57028 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57029 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57030 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57031 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57032 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57033 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57034 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57035 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57036 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57037 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57038 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57039 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57040 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57041 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57042 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57043 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57044 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57045 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57046 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57047 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57048 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57049 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57050 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57051 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57052 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57053 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57054 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57055 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57056 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57057 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57058 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57059 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57060 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57061 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57062 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57063 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57064 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57065 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57066 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57067 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57068 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57069 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57070 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57071 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57072 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57073 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57074 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57075 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57076 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57077 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57078 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57079 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57080 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57081 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57082 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57083 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57084 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57085 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57086 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57087 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57088 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57089 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57090 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57091 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57092 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57093 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57094 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57095 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57096 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57097 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57098 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57099 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57100 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57101 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57102 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57103 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57104 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57105 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57106 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57107 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57108 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57109 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57110 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57111 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57112 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57113 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57114 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57115 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57116 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57117 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57118 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57119 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57120 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57121 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57122 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57123 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57124 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57125 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57126 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57127 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57128 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57129 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57130 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57131 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57132 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57133 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57134 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57135 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57136 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57137 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57138 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57139 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57140 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57141 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57142 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57143 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57144 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57145 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57146 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57147 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57148 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57149 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57150 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57151 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57152 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57153 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57154 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57155 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57156 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57157 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57158 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57159 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57160 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57161 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57162 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57163 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57164 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57165 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57166 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57167 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57168 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57169 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57170 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57171 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57172 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57173 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57174 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57175 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57176 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57177 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57178 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57179 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57180 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57181 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57182 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57183 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57184 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57185 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57186 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57187 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57188 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57189 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57190 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57191 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57192 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57193 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57194 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57195 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57196 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57197 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57198 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57199 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57200 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57201 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57202 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57203 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57204 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57205 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57206 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57207 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57208 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57209 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57210 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57211 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57212 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57213 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57214 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57215 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57216 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57217 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57218 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57219 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57220 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57221 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57222 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57223 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57224 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57225 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57226 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57227 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57228 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57229 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57230 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57231 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57232 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57233 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57234 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57235 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57236 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57237 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57238 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57239 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57240 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57241 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57242 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57243 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57244 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57245 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57246 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57247 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57248 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57249 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57250 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57251 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57252 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57253 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57254 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57255 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57256 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57257 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57258 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57259 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57260 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57261 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57262 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57263 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57264 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57265 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57266 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57267 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57268 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57269 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57270 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57271 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57272 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57273 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57274 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57275 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57276 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57277 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57278 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57279 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57280 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57281 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57282 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57283 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57284 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57285 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57286 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57287 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57288 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57289 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57290 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57291 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57292 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57293 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57294 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57295 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57296 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57297 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57298 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57299 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57300 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57301 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57302 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57303 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57304 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57305 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57306 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57307 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57308 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57309 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57310 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57311 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57312 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57313 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57314 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57315 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57316 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57317 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57318 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57319 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57320 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57321 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57322 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57323 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57324 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57325 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57326 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57327 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57328 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57329 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57330 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57331 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57332 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57333 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57334 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57335 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57336 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57337 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57338 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57339 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57340 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57341 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57342 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57343 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57344 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57345 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57346 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57347 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57348 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57349 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57350 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57351 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57352 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57353 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57354 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57355 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57356 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57357 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57358 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57359 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57360 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57361 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57362 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57363 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57364 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57365 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57366 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57367 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57368 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57369 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57370 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57371 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57372 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57373 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57374 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57375 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57376 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57377 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57378 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57379 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57380 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57381 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57382 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57383 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57384 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57385 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57386 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57387 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57388 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57389 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57390 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57391 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57392 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57393 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57394 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57395 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57396 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57397 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57398 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57399 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57400 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57401 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57402 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57403 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57404 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57405 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57406 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57407 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57408 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57409 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57410 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57411 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57412 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57413 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57414 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57415 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57416 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57417 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57418 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57419 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57420 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57421 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
57422 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
57423 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
57424 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
57425 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
57426 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
57427 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
57428 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
57429 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
57430 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
57431 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
57432 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
57433 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
57434 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
57435 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
57436 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
57437 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
57438 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
57439 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
57440 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
57441
57442 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
57443
57444
57445 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
57446
57447 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
57448 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
57449 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
57450 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
57451 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
57452 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
57453 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
57454 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
57455 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
57456 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
57457 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
57458 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
57459 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
57460 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
57461 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
57462 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
57463 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
57464 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
57465 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
57466 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
57467 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
57468 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
57469 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
57470 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
57471 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
57472 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
57473 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
57474 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
57475 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
57476 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
57477 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
57478 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
57479 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
57480 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
57481 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
57482 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
57483 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
57484 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
57485 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
57486 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
57487 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
57488 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
57489 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
57490 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
57491 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
57492 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
57493 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
57494 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
57495 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
57496 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
57497 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
57498 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
57499 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
57500 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
57501 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
57502 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
57503 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
57504 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
57505 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
57506 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
57507 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
57508 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
57509 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
57510 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
57511 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
57512 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
57513 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
57514 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
57515 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
57516 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
57517 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
57518 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
57519 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
57520 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
57521 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
57522 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
57523 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
57524 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
57525 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
57526 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
57527 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
57528 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
57529 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
57530 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
57531 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
57532 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
57533 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
57534 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
57535 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
57536 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
57537 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
57538 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
57539 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
57540 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
57541 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
57542 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
57543 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
57544 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
57545 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
57546 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
57547 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
57548 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
57549 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
57550 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
57551 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
57552 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
57553 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
57554 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
57555 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
57556 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
57557 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
57558 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
57559 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
57560 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
57561 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
57562 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
57563 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
57564 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
57565 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
57566 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
57567 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
57568 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
57569 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
57570 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
57571 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
57572 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
57573 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
57574 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
57575 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
57576 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
57577 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
57578 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
57579 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
57580 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
57581 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
57582 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
57583 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
57584 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
57585 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
57586 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
57587 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
57588 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
57589 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
57590 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
57591 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
57592 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
57593 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
57594 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
57595 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
57596 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
57597 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
57598 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
57599 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
57600 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
57601 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
57602 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
57603 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
57604 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
57605 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
57606 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
57607 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
57608 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
57609 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
57610 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
57611 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
57612 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
57613 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
57614 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
57615 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
57616 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
57617 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
57618 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
57619 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
57620 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
57621 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
57622 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
57623 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
57624 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
57625 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
57626 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
57627 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
57628 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
57629 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
57630 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
57631 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
57632 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
57633 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
57634 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
57635 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
57636 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
57637 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
57638 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
57639 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
57640 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
57641 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
57642 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
57643 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
57644 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
57645 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
57646 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
57647 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
57648 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
57649 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
57650 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
57651 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
57652 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
57653 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
57654 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
57655 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
57656 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
57657 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
57658 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
57659
57660 // Initialize threading, some globals and such
57661 __wxPyPreStart(d);
57662
57663
57664 // Although these are defined in __version__ they need to be here too so
57665 // that an assert can be done to ensure that the wxPython and the wxWindows
57666 // versions match.
57667 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
57668 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
57669 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
57670
57671 }
57672
wxWidgets (Impactor)