]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
typo fix
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMoveEvent swig_types[79]
2546 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNcPaintEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNotifyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxObject swig_types[83]
2550 #define SWIGTYPE_p_wxOutputStream swig_types[84]
2551 #define SWIGTYPE_p_wxPCXHandler swig_types[85]
2552 #define SWIGTYPE_p_wxPNGHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNMHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPaintEvent swig_types[88]
2555 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaperSize swig_types[90]
2557 #define SWIGTYPE_p_wxPoint swig_types[91]
2558 #define SWIGTYPE_p_wxPoint2D swig_types[92]
2559 #define SWIGTYPE_p_wxPropagateOnce swig_types[93]
2560 #define SWIGTYPE_p_wxPropagationDisabler swig_types[94]
2561 #define SWIGTYPE_p_wxPyApp swig_types[95]
2562 #define SWIGTYPE_p_wxPyCommandEvent swig_types[96]
2563 #define SWIGTYPE_p_wxPyDropTarget swig_types[97]
2564 #define SWIGTYPE_p_wxPyEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[99]
2566 #define SWIGTYPE_p_wxPyImageHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyInputStream swig_types[101]
2568 #define SWIGTYPE_p_wxPySizer swig_types[102]
2569 #define SWIGTYPE_p_wxPyValidator swig_types[103]
2570 #define SWIGTYPE_p_wxQuantize swig_types[104]
2571 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[105]
2572 #define SWIGTYPE_p_wxRealPoint swig_types[106]
2573 #define SWIGTYPE_p_wxRect swig_types[107]
2574 #define SWIGTYPE_p_wxRegion swig_types[108]
2575 #define SWIGTYPE_p_wxScrollEvent swig_types[109]
2576 #define SWIGTYPE_p_wxScrollWinEvent swig_types[110]
2577 #define SWIGTYPE_p_wxSetCursorEvent swig_types[111]
2578 #define SWIGTYPE_p_wxShowEvent swig_types[112]
2579 #define SWIGTYPE_p_wxSize swig_types[113]
2580 #define SWIGTYPE_p_wxSizeEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSizer swig_types[115]
2582 #define SWIGTYPE_p_wxSizerItem swig_types[116]
2583 #define SWIGTYPE_p_wxStaticBox swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[119]
2586 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[120]
2587 #define SWIGTYPE_p_wxTIFFHandler swig_types[121]
2588 #define SWIGTYPE_p_wxToolTip swig_types[122]
2589 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[123]
2590 #define SWIGTYPE_p_wxValidator swig_types[124]
2591 #define SWIGTYPE_p_wxVisualAttributes swig_types[125]
2592 #define SWIGTYPE_p_wxWindow swig_types[126]
2593 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[127]
2594 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[128]
2595 #define SWIGTYPE_p_wxXPMHandler swig_types[129]
2596 #define SWIGTYPE_p_wxZipFSHandler swig_types[130]
2597 static swig_type_info *swig_types[132];
2598 static swig_module_info swig_module = {swig_types, 131, 0, 0, 0, 0};
2599 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2600 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2601
2602 /* -------- TYPES TABLE (END) -------- */
2603
2604 #if (PY_VERSION_HEX <= 0x02000000)
2605 # if !defined(SWIG_PYTHON_CLASSIC)
2606 # error "This python version requires to use swig with the '-classic' option"
2607 # endif
2608 #endif
2609 #if (PY_VERSION_HEX <= 0x02020000)
2610 # error "This python version requires to use swig with the '-nomodern' option"
2611 #endif
2612 #if (PY_VERSION_HEX <= 0x02020000)
2613 # error "This python version requires to use swig with the '-nomodernargs' option"
2614 #endif
2615 #ifndef METH_O
2616 # error "This python version requires to use swig with the '-nofastunpack' option"
2617 #endif
2618
2619 /*-----------------------------------------------
2620 @(target):= _core_.so
2621 ------------------------------------------------*/
2622 #define SWIG_init init_core_
2623
2624 #define SWIG_name "_core_"
2625
2626 #define SWIGVERSION 0x010329
2627
2628
2629 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2630 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2631
2632
2633 #include <stdexcept>
2634
2635
2636 namespace swig {
2637 class PyObject_ptr {
2638 protected:
2639 PyObject *_obj;
2640
2641 public:
2642 PyObject_ptr() :_obj(0)
2643 {
2644 }
2645
2646 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2647 {
2648 Py_XINCREF(_obj);
2649 }
2650
2651 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2652 {
2653 if (initial_ref) Py_XINCREF(_obj);
2654 }
2655
2656 PyObject_ptr & operator=(const PyObject_ptr& item)
2657 {
2658 Py_XINCREF(item._obj);
2659 Py_XDECREF(_obj);
2660 _obj = item._obj;
2661 return *this;
2662 }
2663
2664 ~PyObject_ptr()
2665 {
2666 Py_XDECREF(_obj);
2667 }
2668
2669 operator PyObject *() const
2670 {
2671 return _obj;
2672 }
2673
2674 PyObject *operator->() const
2675 {
2676 return _obj;
2677 }
2678 };
2679 }
2680
2681
2682 namespace swig {
2683 struct PyObject_var : PyObject_ptr {
2684 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2685
2686 PyObject_var & operator = (PyObject* obj)
2687 {
2688 Py_XDECREF(_obj);
2689 _obj = obj;
2690 return *this;
2691 }
2692 };
2693 }
2694
2695
2696 #include "wx/wxPython/wxPython_int.h"
2697 #include "wx/wxPython/pyclasses.h"
2698 #include "wx/wxPython/twoitem.h"
2699
2700
2701 #ifndef wxPyUSE_EXPORT
2702 // Helper functions for dealing with SWIG objects and such. These are
2703 // located here so they know about the SWIG types and functions declared
2704 // in the wrapper code.
2705
2706 #include <wx/hashmap.h>
2707 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2708
2709
2710 // Maintains a hashmap of className to swig_type_info pointers. Given the
2711 // name of a class either looks up the type info in the cache, or scans the
2712 // SWIG tables for it.
2713 extern PyObject* wxPyPtrTypeMap;
2714 static
2715 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2716
2717 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2718
2719 if (typeInfoCache == NULL)
2720 typeInfoCache = new wxPyTypeInfoHashMap;
2721
2722 wxString name(className);
2723 swig_type_info* swigType = (*typeInfoCache)[name];
2724
2725 if (! swigType) {
2726 // it wasn't in the cache, so look it up from SWIG
2727 name.Append(wxT(" *"));
2728 swigType = SWIG_TypeQuery(name.mb_str());
2729
2730 // if it still wasn't found, try looking for a mapped name
2731 if (!swigType) {
2732 PyObject* item;
2733 name = className;
2734
2735 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2736 (char*)(const char*)name.mbc_str())) != NULL) {
2737 name = wxString(PyString_AsString(item), *wxConvCurrent);
2738 name.Append(wxT(" *"));
2739 swigType = SWIG_TypeQuery(name.mb_str());
2740 }
2741 }
2742 if (swigType) {
2743 // and add it to the map if found
2744 (*typeInfoCache)[className] = swigType;
2745 }
2746 }
2747 return swigType;
2748 }
2749
2750
2751 // Check if a class name is a type known to SWIG
2752 bool wxPyCheckSwigType(const wxChar* className) {
2753
2754 swig_type_info* swigType = wxPyFindSwigType(className);
2755 return swigType != NULL;
2756 }
2757
2758
2759 // Given a pointer to a C++ object and a class name, construct a Python proxy
2760 // object for it.
2761 PyObject* wxPyConstructObject(void* ptr,
2762 const wxChar* className,
2763 int setThisOwn) {
2764
2765 swig_type_info* swigType = wxPyFindSwigType(className);
2766 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2767
2768 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2769 }
2770
2771
2772 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2773 // Ensures that the proxy object is of the specified (or derived) type. If
2774 // not able to perform the conversion then a Python exception is set and the
2775 // error should be handled properly in the caller. Returns True on success.
2776 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2777 const wxChar* className) {
2778
2779 swig_type_info* swigType = wxPyFindSwigType(className);
2780 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2781
2782 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2783 }
2784
2785
2786
2787 // Make a SWIGified pointer object suitable for a .this attribute
2788 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2789
2790 PyObject* robj = NULL;
2791
2792 swig_type_info* swigType = wxPyFindSwigType(className);
2793 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2794
2795 robj = PySwigObject_New(ptr, swigType, 0);
2796 return robj;
2797 }
2798
2799
2800 // Python's PyInstance_Check does not return True for instances of new-style
2801 // classes. This should get close enough for both new and old classes but I
2802 // should re-evaluate the need for doing instance checks...
2803 bool wxPyInstance_Check(PyObject* obj) {
2804 return PyObject_HasAttrString(obj, "__class__") != 0;
2805 }
2806
2807
2808 // This one checks if the object is an instance of a SWIG proxy class (it has
2809 // a .this attribute, and the .this attribute is a PySwigObject.)
2810 bool wxPySwigInstance_Check(PyObject* obj) {
2811 static PyObject* this_str = NULL;
2812 if (this_str == NULL)
2813 this_str = PyString_FromString("this");
2814
2815 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2816 if (this_attr) {
2817 bool retval = (PySwigObject_Check(this_attr) != 0);
2818 Py_DECREF(this_attr);
2819 return retval;
2820 }
2821
2822 PyErr_Clear();
2823 return false;
2824 }
2825
2826
2827 // Export a C API in a struct. Other modules will be able to load this from
2828 // the wx._core_ module and will then have safe access to these functions,
2829 // even if they are located in another shared library.
2830 static wxPyCoreAPI API = {
2831
2832 wxPyCheckSwigType,
2833 wxPyConstructObject,
2834 wxPyConvertSwigPtr,
2835 wxPyMakeSwigPtr,
2836
2837 wxPyBeginAllowThreads,
2838 wxPyEndAllowThreads,
2839 wxPyBeginBlockThreads,
2840 wxPyEndBlockThreads,
2841
2842 wxPy_ConvertList,
2843
2844 wxString_in_helper,
2845 Py2wxString,
2846 wx2PyString,
2847
2848 byte_LIST_helper,
2849 int_LIST_helper,
2850 long_LIST_helper,
2851 string_LIST_helper,
2852 wxPoint_LIST_helper,
2853 wxBitmap_LIST_helper,
2854 wxString_LIST_helper,
2855 wxAcceleratorEntry_LIST_helper,
2856
2857 wxSize_helper,
2858 wxPoint_helper,
2859 wxRealPoint_helper,
2860 wxRect_helper,
2861 wxColour_helper,
2862 wxPoint2D_helper,
2863
2864 wxPySimple_typecheck,
2865 wxColour_typecheck,
2866
2867 wxPyCBH_setCallbackInfo,
2868 wxPyCBH_findCallback,
2869 wxPyCBH_callCallback,
2870 wxPyCBH_callCallbackObj,
2871 wxPyCBH_delete,
2872
2873 wxPyMake_wxObject,
2874 wxPyMake_wxSizer,
2875 wxPyPtrTypeMap_Add,
2876 wxPy2int_seq_helper,
2877 wxPy4int_seq_helper,
2878 wxArrayString2PyList_helper,
2879 wxArrayInt2PyList_helper,
2880
2881 wxPyClientData_dtor,
2882 wxPyUserData_dtor,
2883 wxPyOORClientData_dtor,
2884
2885 wxPyCBInputStream_create,
2886 wxPyCBInputStream_copy,
2887
2888 wxPyInstance_Check,
2889 wxPySwigInstance_Check,
2890
2891 wxPyCheckForApp
2892
2893 };
2894
2895 #endif
2896
2897
2898 #if !WXWIN_COMPATIBILITY_2_4
2899 #define wxHIDE_READONLY 0
2900 #endif
2901
2902
2903 #define SWIG_From_long PyInt_FromLong
2904
2905
2906 SWIGINTERNINLINE PyObject *
2907 SWIG_From_int (int value)
2908 {
2909 return SWIG_From_long (value);
2910 }
2911
2912 static const wxString wxPyEmptyString(wxEmptyString);
2913 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2914 return self->GetClassInfo()->GetClassName();
2915 }
2916 SWIGINTERN void wxObject_Destroy(wxObject *self){
2917 delete self;
2918 }
2919
2920 #ifndef __WXMAC__
2921 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2922 #endif
2923
2924
2925 #include <limits.h>
2926 #ifndef LLONG_MIN
2927 # define LLONG_MIN LONG_LONG_MIN
2928 #endif
2929 #ifndef LLONG_MAX
2930 # define LLONG_MAX LONG_LONG_MAX
2931 #endif
2932 #ifndef ULLONG_MAX
2933 # define ULLONG_MAX ULONG_LONG_MAX
2934 #endif
2935
2936
2937 SWIGINTERN int
2938 SWIG_AsVal_long (PyObject* obj, long* val)
2939 {
2940 if (PyNumber_Check(obj)) {
2941 if (val) *val = PyInt_AsLong(obj);
2942 return SWIG_OK;
2943 }
2944 return SWIG_TypeError;
2945 }
2946
2947
2948 SWIGINTERN int
2949 SWIG_AsVal_int (PyObject * obj, int *val)
2950 {
2951 long v;
2952 int res = SWIG_AsVal_long (obj, &v);
2953 if (SWIG_IsOK(res)) {
2954 if ((v < INT_MIN || v > INT_MAX)) {
2955 return SWIG_OverflowError;
2956 } else {
2957 if (val) *val = static_cast< int >(v);
2958 }
2959 }
2960 return res;
2961 }
2962
2963 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2964 wxSize temp, *obj = &temp;
2965 if ( other == Py_None ) return false;
2966 if ( ! wxSize_helper(other, &obj) ) {
2967 PyErr_Clear();
2968 return false;
2969 }
2970 return self->operator==(*obj);
2971 }
2972 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2973 wxSize temp, *obj = &temp;
2974 if ( other == Py_None ) return true;
2975 if ( ! wxSize_helper(other, &obj)) {
2976 PyErr_Clear();
2977 return true;
2978 }
2979 return self->operator!=(*obj);
2980 }
2981
2982 #include <float.h>
2983
2984
2985 SWIGINTERN int
2986 SWIG_AsVal_double (PyObject *obj, double* val)
2987 {
2988 if (PyNumber_Check(obj)) {
2989 if (val) *val = PyFloat_AsDouble(obj);
2990 return SWIG_OK;
2991 }
2992 return SWIG_TypeError;
2993 }
2994
2995
2996 SWIGINTERN int
2997 SWIG_AsVal_float (PyObject * obj, float *val)
2998 {
2999 double v;
3000 int res = SWIG_AsVal_double (obj, &v);
3001 if (SWIG_IsOK(res)) {
3002 if ((v < -FLT_MAX || v > FLT_MAX)) {
3003 return SWIG_OverflowError;
3004 } else {
3005 if (val) *val = static_cast< float >(v);
3006 }
3007 }
3008 return res;
3009 }
3010
3011 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3012 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3013 PyObject* tup = PyTuple_New(2);
3014 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3015 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3016 wxPyEndBlockThreads(blocked);
3017 return tup;
3018 }
3019
3020 #define SWIG_From_double PyFloat_FromDouble
3021
3022 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3023 wxRealPoint temp, *obj = &temp;
3024 if ( other == Py_None ) return false;
3025 if ( ! wxRealPoint_helper(other, &obj) ) {
3026 PyErr_Clear();
3027 return false;
3028 }
3029 return self->operator==(*obj);
3030 }
3031 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3032 wxRealPoint temp, *obj = &temp;
3033 if ( other == Py_None ) return true;
3034 if ( ! wxRealPoint_helper(other, &obj)) {
3035 PyErr_Clear();
3036 return true;
3037 }
3038 return self->operator!=(*obj);
3039 }
3040 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3041 self->x = x;
3042 self->y = y;
3043 }
3044 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3045 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3046 PyObject* tup = PyTuple_New(2);
3047 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3048 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3049 wxPyEndBlockThreads(blocked);
3050 return tup;
3051 }
3052 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3053 wxPoint temp, *obj = &temp;
3054 if ( other == Py_None ) return false;
3055 if ( ! wxPoint_helper(other, &obj) ) {
3056 PyErr_Clear();
3057 return false;
3058 }
3059 return self->operator==(*obj);
3060 }
3061 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3062 wxPoint temp, *obj = &temp;
3063 if ( other == Py_None ) return true;
3064 if ( ! wxPoint_helper(other, &obj)) {
3065 PyErr_Clear();
3066 return true;
3067 }
3068 return self->operator!=(*obj);
3069 }
3070 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3071 self->x = x;
3072 self->y = y;
3073 }
3074 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3075 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3076 PyObject* tup = PyTuple_New(2);
3077 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3078 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3079 wxPyEndBlockThreads(blocked);
3080 return tup;
3081 }
3082 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3083 wxRect temp, *obj = &temp;
3084 if ( other == Py_None ) return false;
3085 if ( ! wxRect_helper(other, &obj) ) {
3086 PyErr_Clear();
3087 return false;
3088 }
3089 return self->operator==(*obj);
3090 }
3091 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3092 wxRect temp, *obj = &temp;
3093 if ( other == Py_None ) return true;
3094 if ( ! wxRect_helper(other, &obj)) {
3095 PyErr_Clear();
3096 return true;
3097 }
3098 return self->operator!=(*obj);
3099 }
3100 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3101 self->x = x;
3102 self->y = y;
3103 self->width = width;
3104 self->height = height;
3105 }
3106 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3107 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3108 PyObject* tup = PyTuple_New(4);
3109 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3110 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3111 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3112 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3113 wxPyEndBlockThreads(blocked);
3114 return tup;
3115 }
3116
3117 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3118 wxRegion reg1(*r1);
3119 wxRegion reg2(*r2);
3120 wxRect dest(0,0,0,0);
3121 PyObject* obj;
3122
3123 reg1.Intersect(reg2);
3124 dest = reg1.GetBox();
3125
3126 if (dest != wxRect(0,0,0,0)) {
3127 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3128 wxRect* newRect = new wxRect(dest);
3129 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3130 wxPyEndBlockThreads(blocked);
3131 return obj;
3132 }
3133 Py_INCREF(Py_None);
3134 return Py_None;
3135 }
3136
3137 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3138 wxPoint2D temp, *obj = &temp;
3139 if ( other == Py_None ) return false;
3140 if ( ! wxPoint2D_helper(other, &obj) ) {
3141 PyErr_Clear();
3142 return false;
3143 }
3144 return self->operator==(*obj);
3145 }
3146 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3147 wxPoint2D temp, *obj = &temp;
3148 if ( other == Py_None ) return true;
3149 if ( ! wxPoint2D_helper(other, &obj)) {
3150 PyErr_Clear();
3151 return true;
3152 }
3153 return self->operator!=(*obj);
3154 }
3155 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3156 self->m_x = x;
3157 self->m_y = y;
3158 }
3159 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3160 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3161 PyObject* tup = PyTuple_New(2);
3162 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3163 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3164 wxPyEndBlockThreads(blocked);
3165 return tup;
3166 }
3167
3168 #include "wx/wxPython/pyistream.h"
3169
3170 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3171 wxInputStream* wxis = wxPyCBInputStream::create(p);
3172 if (wxis)
3173 return new wxPyInputStream(wxis);
3174 else
3175 return NULL;
3176 }
3177
3178 SWIGINTERN swig_type_info*
3179 SWIG_pchar_descriptor()
3180 {
3181 static int init = 0;
3182 static swig_type_info* info = 0;
3183 if (!init) {
3184 info = SWIG_TypeQuery("_p_char");
3185 init = 1;
3186 }
3187 return info;
3188 }
3189
3190
3191 SWIGINTERNINLINE PyObject *
3192 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3193 {
3194 if (carray) {
3195 if (size > INT_MAX) {
3196 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3197 return pchar_descriptor ?
3198 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3199 } else {
3200 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3201 }
3202 } else {
3203 return SWIG_Py_Void();
3204 }
3205 }
3206
3207
3208 SWIGINTERNINLINE PyObject *
3209 SWIG_From_char (char c)
3210 {
3211 return SWIG_FromCharPtrAndSize(&c,1);
3212 }
3213
3214
3215 SWIGINTERNINLINE PyObject*
3216 SWIG_From_unsigned_SS_long (unsigned long value)
3217 {
3218 return (value > LONG_MAX) ?
3219 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3220 }
3221
3222
3223 SWIGINTERNINLINE PyObject *
3224 SWIG_From_size_t (size_t value)
3225 {
3226 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3227 }
3228
3229
3230 SWIGINTERN int
3231 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3232 {
3233 if (PyString_Check(obj)) {
3234 char *cstr; Py_ssize_t len;
3235 PyString_AsStringAndSize(obj, &cstr, &len);
3236 if (cptr) {
3237 if (alloc) {
3238 /*
3239 In python the user should not be able to modify the inner
3240 string representation. To warranty that, if you define
3241 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3242 buffer is always returned.
3243
3244 The default behavior is just to return the pointer value,
3245 so, be careful.
3246 */
3247 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3248 if (*alloc != SWIG_OLDOBJ)
3249 #else
3250 if (*alloc == SWIG_NEWOBJ)
3251 #endif
3252 {
3253 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3254 *alloc = SWIG_NEWOBJ;
3255 }
3256 else {
3257 *cptr = cstr;
3258 *alloc = SWIG_OLDOBJ;
3259 }
3260 } else {
3261 *cptr = PyString_AsString(obj);
3262 }
3263 }
3264 if (psize) *psize = len + 1;
3265 return SWIG_OK;
3266 } else {
3267 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3268 if (pchar_descriptor) {
3269 void* vptr = 0;
3270 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3271 if (cptr) *cptr = (char *) vptr;
3272 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3273 if (alloc) *alloc = SWIG_OLDOBJ;
3274 return SWIG_OK;
3275 }
3276 }
3277 }
3278 return SWIG_TypeError;
3279 }
3280
3281
3282 SWIGINTERN int
3283 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3284 {
3285 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3286 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3287 if (SWIG_IsOK(res)) {
3288 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3289 if (csize <= size) {
3290 if (val) {
3291 if (csize) memcpy(val, cptr, csize*sizeof(char));
3292 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3293 }
3294 if (alloc == SWIG_NEWOBJ) {
3295 delete[] cptr;
3296 res = SWIG_DelNewMask(res);
3297 }
3298 return res;
3299 }
3300 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3301 }
3302 return SWIG_TypeError;
3303 }
3304
3305
3306 SWIGINTERN int
3307 SWIG_AsVal_char (PyObject * obj, char *val)
3308 {
3309 int res = SWIG_AsCharArray(obj, val, 1);
3310 if (!SWIG_IsOK(res)) {
3311 long v;
3312 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3313 if (SWIG_IsOK(res)) {
3314 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3315 if (val) *val = static_cast< char >(v);
3316 } else {
3317 res = SWIG_OverflowError;
3318 }
3319 }
3320 }
3321 return res;
3322 }
3323
3324 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3325 // We use only strings for the streams, not unicode
3326 PyObject* str = PyObject_Str(obj);
3327 if (! str) {
3328 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3329 return;
3330 }
3331 self->Write(PyString_AS_STRING(str),
3332 PyString_GET_SIZE(str));
3333 Py_DECREF(str);
3334 }
3335
3336 #include "wx/wxPython/pyistream.h"
3337
3338
3339 class wxPyFileSystemHandler : public wxFileSystemHandler
3340 {
3341 public:
3342 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3343
3344 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3345 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3346 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3347 DEC_PYCALLBACK_STRING__pure(FindNext);
3348
3349 wxString GetProtocol(const wxString& location) {
3350 return wxFileSystemHandler::GetProtocol(location);
3351 }
3352
3353 wxString GetLeftLocation(const wxString& location) {
3354 return wxFileSystemHandler::GetLeftLocation(location);
3355 }
3356
3357 wxString GetAnchor(const wxString& location) {
3358 return wxFileSystemHandler::GetAnchor(location);
3359 }
3360
3361 wxString GetRightLocation(const wxString& location) {
3362 return wxFileSystemHandler::GetRightLocation(location);
3363 }
3364
3365 wxString GetMimeTypeFromExt(const wxString& location) {
3366 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3367 }
3368
3369 PYPRIVATE;
3370 };
3371
3372
3373 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3374 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3375 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3376 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3377
3378
3379 SWIGINTERN int
3380 SWIG_AsVal_bool (PyObject *obj, bool *val)
3381 {
3382 if (obj == Py_True) {
3383 if (val) *val = true;
3384 return SWIG_OK;
3385 } else if (obj == Py_False) {
3386 if (val) *val = false;
3387 return SWIG_OK;
3388 } else {
3389 long v = 0;
3390 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3391 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3392 return res;
3393 }
3394 }
3395
3396 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3397 wxFileName fname = wxFileSystem::URLToFileName(url);
3398 return fname.GetFullPath();
3399 }
3400
3401 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3402 wxImage& image,
3403 long type) {
3404 wxMemoryFSHandler::AddFile(filename, image, type);
3405 }
3406
3407 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3408 const wxBitmap& bitmap,
3409 long type) {
3410 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3411 }
3412
3413 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3414 PyObject* data) {
3415 if (! PyString_Check(data)) {
3416 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3417 "Expected string object"));
3418 return;
3419 }
3420
3421 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3422 void* ptr = (void*)PyString_AsString(data);
3423 size_t size = PyString_Size(data);
3424 wxPyEndBlockThreads(blocked);
3425
3426 wxMemoryFSHandler::AddFile(filename, ptr, size);
3427 }
3428
3429
3430 #include "wx/wxPython/pyistream.h"
3431
3432
3433 SWIGINTERN int
3434 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3435 {
3436 long v = 0;
3437 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3438 return SWIG_TypeError;
3439 }
3440 else if (val)
3441 *val = (unsigned long)v;
3442 return SWIG_OK;
3443 }
3444
3445
3446 SWIGINTERN int
3447 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3448 {
3449 unsigned long v;
3450 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3451 if (SWIG_IsOK(res)) {
3452 if ((v > UCHAR_MAX)) {
3453 return SWIG_OverflowError;
3454 } else {
3455 if (val) *val = static_cast< unsigned char >(v);
3456 }
3457 }
3458 return res;
3459 }
3460
3461
3462 SWIGINTERNINLINE PyObject *
3463 SWIG_From_unsigned_SS_char (unsigned char value)
3464 {
3465 return SWIG_From_unsigned_SS_long (value);
3466 }
3467
3468 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3469 wxImageHistogramEntry e = (*self)[key];
3470 return e.value;
3471 }
3472 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3473 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3474 wxImageHistogramEntry e = (*self)[key];
3475 return e.value;
3476 }
3477 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3478 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3479 colour.Green(),
3480 colour.Blue());
3481 wxImageHistogramEntry e = (*self)[key];
3482 return e.value;
3483 }
3484
3485 typedef unsigned char* buffer;
3486
3487
3488 // Pull the nested class out to the top level for SWIG's sake
3489 #define wxImage_RGBValue wxImage::RGBValue
3490 #define wxImage_HSVValue wxImage::HSVValue
3491
3492 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3493 if (width > 0 && height > 0)
3494 return new wxImage(width, height, clear);
3495 else
3496 return new wxImage;
3497 }
3498 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3499 return new wxImage(bitmap.ConvertToImage());
3500 }
3501 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3502 if (DATASIZE != width*height*3) {
3503 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3504 return NULL;
3505 }
3506
3507 // Copy the source data so the wxImage can clean it up later
3508 buffer copy = (buffer)malloc(DATASIZE);
3509 if (copy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(copy, data, DATASIZE);
3514 return new wxImage(width, height, copy, false);
3515 }
3516 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3517 if (DATASIZE != width*height*3) {
3518 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3519 return NULL;
3520 }
3521 if (ALPHASIZE != width*height) {
3522 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3523 return NULL;
3524 }
3525
3526 // Copy the source data so the wxImage can clean it up later
3527 buffer dcopy = (buffer)malloc(DATASIZE);
3528 if (dcopy == NULL) {
3529 wxPyBLOCK_THREADS(PyErr_NoMemory());
3530 return NULL;
3531 }
3532 memcpy(dcopy, data, DATASIZE);
3533
3534 buffer acopy = (buffer)malloc(ALPHASIZE);
3535 if (acopy == NULL) {
3536 wxPyBLOCK_THREADS(PyErr_NoMemory());
3537 return NULL;
3538 }
3539 memcpy(acopy, alpha, ALPHASIZE);
3540
3541 return new wxImage(width, height, dcopy, acopy, false);
3542 }
3543 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3544 wxSize size(self->GetWidth(), self->GetHeight());
3545 return size;
3546 }
3547 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3548 buffer data = self->GetData();
3549 int len = self->GetWidth() * self->GetHeight() * 3;
3550 PyObject* rv;
3551 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3552 return rv;
3553 }
3554 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3555 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3556 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3557 return;
3558 }
3559 buffer copy = (buffer)malloc(DATASIZE);
3560 if (copy == NULL) {
3561 wxPyBLOCK_THREADS(PyErr_NoMemory());
3562 return;
3563 }
3564 memcpy(copy, data, DATASIZE);
3565 self->SetData(copy, false);
3566 // wxImage takes ownership of copy...
3567 }
3568 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3569 buffer data = self->GetData();
3570 int len = self->GetWidth() * self->GetHeight() * 3;
3571 PyObject* rv;
3572 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3573 return rv;
3574 }
3575 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3576 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3577 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3578 return;
3579 }
3580 self->SetData(data, true);
3581 }
3582 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3583 buffer data = self->GetAlpha();
3584 if (! data) {
3585 RETURN_NONE();
3586 } else {
3587 int len = self->GetWidth() * self->GetHeight();
3588 PyObject* rv;
3589 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3590 return rv;
3591 }
3592 }
3593 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3594 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3596 return;
3597 }
3598 buffer acopy = (buffer)malloc(ALPHASIZE);
3599 if (acopy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(acopy, alpha, ALPHASIZE);
3604 self->SetAlpha(acopy, false);
3605 // wxImage takes ownership of acopy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3608 buffer data = self->GetAlpha();
3609 int len = self->GetWidth() * self->GetHeight();
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3615 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3617 return;
3618 }
3619 self->SetAlpha(alpha, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetHandlers(){
3622 wxList& list = wxImage::GetHandlers();
3623 return wxPy_ConvertList(&list);
3624 }
3625 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3626 wxBitmap bitmap(*self, depth);
3627 return bitmap;
3628 }
3629 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3630 wxImage mono = self->ConvertToMono( red, green, blue );
3631 wxBitmap bitmap( mono, 1 );
3632 return bitmap;
3633 }
3634 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3635 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3636 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3637 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3638 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3639 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3640 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3641 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3642 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3643 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3644 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3645 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3646 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3647 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3648 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3649
3650 #include <wx/quantize.h>
3651
3652 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3653 return wxQuantize::Quantize(src, dest,
3654 //NULL, // palette
3655 desiredNoColours,
3656 NULL, // eightBitData
3657 flags);
3658 }
3659 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3660 if (PyCallable_Check(func)) {
3661 self->Connect(id, lastId, eventType,
3662 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3663 new wxPyCallback(func));
3664 }
3665 else if (func == Py_None) {
3666 self->Disconnect(id, lastId, eventType,
3667 (wxObjectEventFunction)
3668 &wxPyCallback::EventThunker);
3669 }
3670 else {
3671 wxPyBLOCK_THREADS(
3672 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3673 }
3674 }
3675 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3676 return self->Disconnect(id, lastId, eventType,
3677 (wxObjectEventFunction)
3678 &wxPyCallback::EventThunker);
3679 }
3680 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3681 if (_self && _self != Py_None) {
3682 self->SetClientObject(new wxPyOORClientData(_self, incref));
3683 }
3684 else {
3685 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3686 if (data) {
3687 self->SetClientObject(NULL); // This will delete it too
3688 }
3689 }
3690 }
3691
3692 #if ! wxUSE_HOTKEY
3693 #define wxEVT_HOTKEY -9999
3694 #endif
3695
3696 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3697 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3698 if (data) {
3699 Py_INCREF(data->m_obj);
3700 return data->m_obj;
3701 } else {
3702 Py_INCREF(Py_None);
3703 return Py_None;
3704 }
3705 }
3706 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3707 wxPyClientData* data = new wxPyClientData(clientData);
3708 self->SetClientObject(data);
3709 }
3710 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3711 #if wxUSE_UNICODE
3712 return self->GetUnicodeKey();
3713 #else
3714 return 0;
3715 #endif
3716 }
3717 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3718 #if wxUSE_UNICODE
3719 self->m_uniChar = uniChar;
3720 #endif
3721 }
3722
3723 SWIGINTERNINLINE PyObject *
3724 SWIG_From_unsigned_SS_int (unsigned int value)
3725 {
3726 return SWIG_From_unsigned_SS_long (value);
3727 }
3728
3729
3730 SWIGINTERN int
3731 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3732 {
3733 unsigned long v;
3734 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3735 if (SWIG_IsOK(res)) {
3736 if ((v > UINT_MAX)) {
3737 return SWIG_OverflowError;
3738 } else {
3739 if (val) *val = static_cast< unsigned int >(v);
3740 }
3741 }
3742 return res;
3743 }
3744
3745 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3746 self->m_size = size;
3747 }
3748 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3749 int count = self->GetNumberOfFiles();
3750 wxString* files = self->GetFiles();
3751 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3752 PyObject* list = PyList_New(count);
3753
3754 if (!list) {
3755 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3756 wxPyEndBlockThreads(blocked);
3757 return NULL;
3758 }
3759
3760 for (int i=0; i<count; i++) {
3761 PyList_SetItem(list, i, wx2PyString(files[i]));
3762 }
3763 wxPyEndBlockThreads(blocked);
3764 return list;
3765 }
3766
3767
3768 SWIGINTERN wxPyApp *new_wxPyApp(){
3769 wxPythonApp = new wxPyApp();
3770 return wxPythonApp;
3771 }
3772
3773 void wxApp_CleanUp() {
3774 __wxPyCleanup();
3775 }
3776
3777
3778 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3779
3780
3781
3782
3783
3784 SWIGINTERNINLINE PyObject *
3785 SWIG_FromCharPtr(const char *cptr)
3786 {
3787 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3788 }
3789
3790
3791 #if 0 // #ifdef __WXMAC__
3792
3793 // A dummy class that raises an exception if used...
3794 class wxEventLoop
3795 {
3796 public:
3797 wxEventLoop() { wxPyRaiseNotImplemented(); }
3798 int Run() { return 0; }
3799 void Exit(int rc = 0) {}
3800 bool Pending() const { return false; }
3801 bool Dispatch() { return false; }
3802 bool IsRunning() const { return false; }
3803 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3804 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3805 };
3806
3807 #else
3808
3809 #include <wx/evtloop.h>
3810
3811 #endif
3812
3813
3814
3815 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3816 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3817 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3818 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3819 wxWindowList& list = self->GetChildren();
3820 return wxPy_ConvertList(&list);
3821 }
3822 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3823 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3824 #if wxUSE_HOTKEY
3825 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3826 #else
3827 return false;
3828 #endif
3829 }
3830 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3831
3832
3833
3834 return false;
3835
3836 }
3837 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3838 return wxPyGetWinHandle(self);
3839 }
3840 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3841 self->AssociateHandle((WXWidget)handle);
3842 }
3843
3844 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3845 return wxWindow::FindWindowById(id, parent);
3846 }
3847
3848 wxWindow* wxFindWindowByName( const wxString& name,
3849 const wxWindow *parent = NULL ) {
3850 return wxWindow::FindWindowByName(name, parent);
3851 }
3852
3853 wxWindow* wxFindWindowByLabel( const wxString& label,
3854 const wxWindow *parent = NULL ) {
3855 return wxWindow::FindWindowByLabel(label, parent);
3856 }
3857
3858
3859 #ifdef __WXMSW__
3860 #include <wx/msw/private.h> // to get wxGetWindowId
3861 #endif
3862
3863
3864 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3865 #ifdef __WXMSW__
3866 WXHWND hWnd = (WXHWND)_hWnd;
3867 long id = wxGetWindowId(hWnd);
3868 wxWindow* win = new wxWindow;
3869 if (parent)
3870 parent->AddChild(win);
3871 win->SetEventHandler(win);
3872 win->SetHWND(hWnd);
3873 win->SetId(id);
3874 win->SubclassWin(hWnd);
3875 win->AdoptAttributesFromHWND();
3876 win->SetupColours();
3877 return win;
3878 #else
3879 wxPyRaiseNotImplemented();
3880 return NULL;
3881 #endif
3882 }
3883
3884
3885 PyObject* GetTopLevelWindows() {
3886 return wxPy_ConvertList(&wxTopLevelWindows);
3887 }
3888
3889
3890 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3891 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3892 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3893
3894 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3895
3896
3897 SWIGINTERNINLINE int
3898 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3899 {
3900 unsigned long v;
3901 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3902 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3903 return res;
3904 }
3905
3906 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3907 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3908 wxMenuItemList& list = self->GetMenuItems();
3909 return wxPy_ConvertList(&list);
3910 }
3911 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3912 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3913 static const wxString wxPyControlNameStr(wxControlNameStr);
3914 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3915 if (clientData) {
3916 wxPyClientData* data = new wxPyClientData(clientData);
3917 return self->Append(item, data);
3918 } else
3919 return self->Append(item);
3920 }
3921 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3922 if (clientData) {
3923 wxPyClientData* data = new wxPyClientData(clientData);
3924 return self->Insert(item, pos, data);
3925 } else
3926 return self->Insert(item, pos);
3927 }
3928 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3929 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3930 if (data) {
3931 Py_INCREF(data->m_obj);
3932 return data->m_obj;
3933 } else {
3934 Py_INCREF(Py_None);
3935 return Py_None;
3936 }
3937 }
3938 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3939 wxPyClientData* data = new wxPyClientData(clientData);
3940 self->SetClientObject(n, data);
3941 }
3942
3943
3944 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3945 wxPyUserData* data = NULL;
3946 if ( userData ) {
3947 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3948 data = new wxPyUserData(userData);
3949 wxPyEndBlockThreads(blocked);
3950 }
3951 return new wxSizerItem(window, proportion, flag, border, data);
3952 }
3953 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3954 wxPyUserData* data = NULL;
3955 if ( userData ) {
3956 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3957 data = new wxPyUserData(userData);
3958 wxPyEndBlockThreads(blocked);
3959 }
3960 return new wxSizerItem(width, height, proportion, flag, border, data);
3961 }
3962 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3963 wxPyUserData* data = NULL;
3964 if ( userData ) {
3965 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3966 data = new wxPyUserData(userData);
3967 wxPyEndBlockThreads(blocked);
3968 }
3969 return new wxSizerItem(sizer, proportion, flag, border, data);
3970 }
3971
3972 SWIGINTERNINLINE PyObject *
3973 SWIG_From_float (float value)
3974 {
3975 return SWIG_From_double (value);
3976 }
3977
3978 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3979 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3980 if (data) {
3981 Py_INCREF(data->m_obj);
3982 return data->m_obj;
3983 } else {
3984 Py_INCREF(Py_None);
3985 return Py_None;
3986 }
3987 }
3988 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3989 wxPyUserData* data = NULL;
3990 if ( userData ) {
3991 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3992 data = new wxPyUserData(userData);
3993 wxPyEndBlockThreads(blocked);
3994 }
3995 self->SetUserData(data);
3996 }
3997
3998 // Figure out the type of the sizer item
3999
4000 struct wxPySizerItemInfo {
4001 wxPySizerItemInfo()
4002 : window(NULL), sizer(NULL), gotSize(false),
4003 size(wxDefaultSize), gotPos(false), pos(-1)
4004 {}
4005
4006 wxWindow* window;
4007 wxSizer* sizer;
4008 bool gotSize;
4009 wxSize size;
4010 bool gotPos;
4011 int pos;
4012 };
4013
4014 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4015
4016 wxPySizerItemInfo info;
4017 wxSize size;
4018 wxSize* sizePtr = &size;
4019
4020 // Find out what the type of the item is
4021 // try wxWindow
4022 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4023 PyErr_Clear();
4024 info.window = NULL;
4025
4026 // try wxSizer
4027 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4028 PyErr_Clear();
4029 info.sizer = NULL;
4030
4031 // try wxSize or (w,h)
4032 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4033 info.size = *sizePtr;
4034 info.gotSize = true;
4035 }
4036
4037 // or a single int
4038 if (checkIdx && PyInt_Check(item)) {
4039 info.pos = PyInt_AsLong(item);
4040 info.gotPos = true;
4041 }
4042 }
4043 }
4044
4045 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4046 // no expected type, figure out what kind of error message to generate
4047 if ( !checkSize && !checkIdx )
4048 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4049 else if ( checkSize && !checkIdx )
4050 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4051 else if ( !checkSize && checkIdx)
4052 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4053 else
4054 // can this one happen?
4055 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4056 }
4057
4058 return info;
4059 }
4060
4061 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4062 if (!self->GetClientObject())
4063 self->SetClientObject(new wxPyOORClientData(_self));
4064 }
4065 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4066
4067 wxPyUserData* data = NULL;
4068 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4069 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4070 if ( userData && (info.window || info.sizer || info.gotSize) )
4071 data = new wxPyUserData(userData);
4072 if ( info.sizer )
4073 PyObject_SetAttrString(item,"thisown",Py_False);
4074 wxPyEndBlockThreads(blocked);
4075
4076 // Now call the real Add method if a valid item type was found
4077 if ( info.window )
4078 return self->Add(info.window, proportion, flag, border, data);
4079 else if ( info.sizer )
4080 return self->Add(info.sizer, proportion, flag, border, data);
4081 else if (info.gotSize)
4082 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4083 proportion, flag, border, data);
4084 else
4085 return NULL;
4086 }
4087 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4088
4089 wxPyUserData* data = NULL;
4090 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4091 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4092 if ( userData && (info.window || info.sizer || info.gotSize) )
4093 data = new wxPyUserData(userData);
4094 if ( info.sizer )
4095 PyObject_SetAttrString(item,"thisown",Py_False);
4096 wxPyEndBlockThreads(blocked);
4097
4098 // Now call the real Insert method if a valid item type was found
4099 if ( info.window )
4100 return self->Insert(before, info.window, proportion, flag, border, data);
4101 else if ( info.sizer )
4102 return self->Insert(before, info.sizer, proportion, flag, border, data);
4103 else if (info.gotSize)
4104 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4105 proportion, flag, border, data);
4106 else
4107 return NULL;
4108 }
4109 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4110
4111 wxPyUserData* data = NULL;
4112 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4113 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4114 if ( userData && (info.window || info.sizer || info.gotSize) )
4115 data = new wxPyUserData(userData);
4116 if ( info.sizer )
4117 PyObject_SetAttrString(item,"thisown",Py_False);
4118 wxPyEndBlockThreads(blocked);
4119
4120 // Now call the real Prepend method if a valid item type was found
4121 if ( info.window )
4122 return self->Prepend(info.window, proportion, flag, border, data);
4123 else if ( info.sizer )
4124 return self->Prepend(info.sizer, proportion, flag, border, data);
4125 else if (info.gotSize)
4126 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4127 proportion, flag, border, data);
4128 else
4129 return NULL;
4130 }
4131 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4132 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4133 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4134 wxPyEndBlockThreads(blocked);
4135 if ( info.window )
4136 return self->Remove(info.window);
4137 else if ( info.sizer )
4138 return self->Remove(info.sizer);
4139 else if ( info.gotPos )
4140 return self->Remove(info.pos);
4141 else
4142 return false;
4143 }
4144 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4145 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4146 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4147 wxPyEndBlockThreads(blocked);
4148 if ( info.window )
4149 return self->Detach(info.window);
4150 else if ( info.sizer )
4151 return self->Detach(info.sizer);
4152 else if ( info.gotPos )
4153 return self->Detach(info.pos);
4154 else
4155 return false;
4156 }
4157 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4158 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4159 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4160 wxPyEndBlockThreads(blocked);
4161 if ( info.window )
4162 return self->GetItem(info.window);
4163 else if ( info.sizer )
4164 return self->GetItem(info.sizer);
4165 else if ( info.gotPos )
4166 return self->GetItem(info.pos);
4167 else
4168 return NULL;
4169 }
4170 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4171 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4172 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4173 wxPyEndBlockThreads(blocked);
4174 if ( info.window )
4175 self->SetItemMinSize(info.window, size);
4176 else if ( info.sizer )
4177 self->SetItemMinSize(info.sizer, size);
4178 else if ( info.gotPos )
4179 self->SetItemMinSize(info.pos, size);
4180 }
4181 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4182 wxSizerItemList& list = self->GetChildren();
4183 return wxPy_ConvertList(&list);
4184 }
4185 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4187 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4188 wxPyEndBlockThreads(blocked);
4189 if ( info.window )
4190 return self->Show(info.window, show, recursive);
4191 else if ( info.sizer )
4192 return self->Show(info.sizer, show, recursive);
4193 else if ( info.gotPos )
4194 return self->Show(info.pos, show);
4195 else
4196 return false;
4197 }
4198 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4199 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4200 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4201 wxPyEndBlockThreads(blocked);
4202 if ( info.window )
4203 return self->IsShown(info.window);
4204 else if ( info.sizer )
4205 return self->IsShown(info.sizer);
4206 else if ( info.gotPos )
4207 return self->IsShown(info.pos);
4208 else
4209 return false;
4210 }
4211
4212 // See pyclasses.h
4213 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4214 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4215 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4216
4217
4218
4219
4220 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4221 {
4222 if (source == Py_None) {
4223 **obj = wxGBPosition(-1,-1);
4224 return true;
4225 }
4226 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4227 }
4228
4229 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4230 {
4231 if (source == Py_None) {
4232 **obj = wxGBSpan(-1,-1);
4233 return true;
4234 }
4235 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4236 }
4237
4238
4239 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4240 wxGBPosition temp, *obj = &temp;
4241 if ( other == Py_None ) return false;
4242 if ( ! wxGBPosition_helper(other, &obj) ) {
4243 PyErr_Clear();
4244 return false;
4245 }
4246 return self->operator==(*obj);
4247 }
4248 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4249 wxGBPosition temp, *obj = &temp;
4250 if ( other == Py_None ) return true;
4251 if ( ! wxGBPosition_helper(other, &obj)) {
4252 PyErr_Clear();
4253 return true;
4254 }
4255 return self->operator!=(*obj);
4256 }
4257 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4258 self->SetRow(row);
4259 self->SetCol(col);
4260 }
4261 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4262 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4263 PyObject* tup = PyTuple_New(2);
4264 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4265 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4266 wxPyEndBlockThreads(blocked);
4267 return tup;
4268 }
4269 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4270 wxGBSpan temp, *obj = &temp;
4271 if ( other == Py_None ) return false;
4272 if ( ! wxGBSpan_helper(other, &obj) ) {
4273 PyErr_Clear();
4274 return false;
4275 }
4276 return self->operator==(*obj);
4277 }
4278 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4279 wxGBSpan temp, *obj = &temp;
4280 if ( other == Py_None ) return true;
4281 if ( ! wxGBSpan_helper(other, &obj)) {
4282 PyErr_Clear();
4283 return true;
4284 }
4285 return self->operator!=(*obj);
4286 }
4287 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4288 self->SetRowspan(rowspan);
4289 self->SetColspan(colspan);
4290 }
4291 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4292 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4293 PyObject* tup = PyTuple_New(2);
4294 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4295 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4296 wxPyEndBlockThreads(blocked);
4297 return tup;
4298 }
4299 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4300 wxPyUserData* data = NULL;
4301 if ( userData ) {
4302 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4303 data = new wxPyUserData(userData);
4304 wxPyEndBlockThreads(blocked);
4305 }
4306 return new wxGBSizerItem(window, pos, span, flag, border, data);
4307 }
4308 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4309 wxPyUserData* data = NULL;
4310 if ( userData ) {
4311 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4312 data = new wxPyUserData(userData);
4313 wxPyEndBlockThreads(blocked);
4314 }
4315 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4316 }
4317 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4318 wxPyUserData* data = NULL;
4319 if ( userData ) {
4320 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4321 data = new wxPyUserData(userData);
4322 wxPyEndBlockThreads(blocked);
4323 }
4324 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4325 }
4326 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4327 int row, col;
4328 self->GetEndPos(row, col);
4329 return wxGBPosition(row, col);
4330 }
4331 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4332
4333 wxPyUserData* data = NULL;
4334 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4335 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4336 if ( userData && (info.window || info.sizer || info.gotSize) )
4337 data = new wxPyUserData(userData);
4338 if ( info.sizer )
4339 PyObject_SetAttrString(item,"thisown",Py_False);
4340 wxPyEndBlockThreads(blocked);
4341
4342 // Now call the real Add method if a valid item type was found
4343 if ( info.window )
4344 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4345 else if ( info.sizer )
4346 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4347 else if (info.gotSize)
4348 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4349 pos, span, flag, border, data);
4350 return NULL;
4351 }
4352
4353
4354 #ifdef __cplusplus
4355 extern "C" {
4356 #endif
4357 SWIGINTERN int EmptyString_set(PyObject *) {
4358 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4359 return 1;
4360 }
4361
4362
4363 SWIGINTERN PyObject *EmptyString_get(void) {
4364 PyObject *pyobj = 0;
4365
4366 {
4367 #if wxUSE_UNICODE
4368 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4369 #else
4370 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4371 #endif
4372 }
4373 return pyobj;
4374 }
4375
4376
4377 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4378 PyObject *resultobj = 0;
4379 wxObject *arg1 = (wxObject *) 0 ;
4380 wxString result;
4381 void *argp1 = 0 ;
4382 int res1 = 0 ;
4383 PyObject *swig_obj[1] ;
4384
4385 if (!args) SWIG_fail;
4386 swig_obj[0] = args;
4387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4388 if (!SWIG_IsOK(res1)) {
4389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4390 }
4391 arg1 = reinterpret_cast< wxObject * >(argp1);
4392 {
4393 PyThreadState* __tstate = wxPyBeginAllowThreads();
4394 result = wxObject_GetClassName(arg1);
4395 wxPyEndAllowThreads(__tstate);
4396 if (PyErr_Occurred()) SWIG_fail;
4397 }
4398 {
4399 #if wxUSE_UNICODE
4400 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4401 #else
4402 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4403 #endif
4404 }
4405 return resultobj;
4406 fail:
4407 return NULL;
4408 }
4409
4410
4411 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4412 PyObject *resultobj = 0;
4413 wxObject *arg1 = (wxObject *) 0 ;
4414 void *argp1 = 0 ;
4415 int res1 = 0 ;
4416 PyObject *swig_obj[1] ;
4417
4418 if (!args) SWIG_fail;
4419 swig_obj[0] = args;
4420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4421 if (!SWIG_IsOK(res1)) {
4422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4423 }
4424 arg1 = reinterpret_cast< wxObject * >(argp1);
4425 {
4426 PyThreadState* __tstate = wxPyBeginAllowThreads();
4427 wxObject_Destroy(arg1);
4428 wxPyEndAllowThreads(__tstate);
4429 if (PyErr_Occurred()) SWIG_fail;
4430 }
4431 resultobj = SWIG_Py_Void();
4432 return resultobj;
4433 fail:
4434 return NULL;
4435 }
4436
4437
4438 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4439 PyObject *obj;
4440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4441 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4442 return SWIG_Py_Void();
4443 }
4444
4445 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4446 PyObject *resultobj = 0;
4447 wxSize *arg1 = (wxSize *) 0 ;
4448 int arg2 ;
4449 void *argp1 = 0 ;
4450 int res1 = 0 ;
4451 int val2 ;
4452 int ecode2 = 0 ;
4453 PyObject *swig_obj[2] ;
4454
4455 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4457 if (!SWIG_IsOK(res1)) {
4458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4459 }
4460 arg1 = reinterpret_cast< wxSize * >(argp1);
4461 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4462 if (!SWIG_IsOK(ecode2)) {
4463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4464 }
4465 arg2 = static_cast< int >(val2);
4466 if (arg1) (arg1)->x = arg2;
4467
4468 resultobj = SWIG_Py_Void();
4469 return resultobj;
4470 fail:
4471 return NULL;
4472 }
4473
4474
4475 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4476 PyObject *resultobj = 0;
4477 wxSize *arg1 = (wxSize *) 0 ;
4478 int result;
4479 void *argp1 = 0 ;
4480 int res1 = 0 ;
4481 PyObject *swig_obj[1] ;
4482
4483 if (!args) SWIG_fail;
4484 swig_obj[0] = args;
4485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4486 if (!SWIG_IsOK(res1)) {
4487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4488 }
4489 arg1 = reinterpret_cast< wxSize * >(argp1);
4490 result = (int) ((arg1)->x);
4491 resultobj = SWIG_From_int(static_cast< int >(result));
4492 return resultobj;
4493 fail:
4494 return NULL;
4495 }
4496
4497
4498 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4499 PyObject *resultobj = 0;
4500 wxSize *arg1 = (wxSize *) 0 ;
4501 int arg2 ;
4502 void *argp1 = 0 ;
4503 int res1 = 0 ;
4504 int val2 ;
4505 int ecode2 = 0 ;
4506 PyObject *swig_obj[2] ;
4507
4508 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4510 if (!SWIG_IsOK(res1)) {
4511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4512 }
4513 arg1 = reinterpret_cast< wxSize * >(argp1);
4514 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4515 if (!SWIG_IsOK(ecode2)) {
4516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4517 }
4518 arg2 = static_cast< int >(val2);
4519 if (arg1) (arg1)->y = arg2;
4520
4521 resultobj = SWIG_Py_Void();
4522 return resultobj;
4523 fail:
4524 return NULL;
4525 }
4526
4527
4528 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4529 PyObject *resultobj = 0;
4530 wxSize *arg1 = (wxSize *) 0 ;
4531 int result;
4532 void *argp1 = 0 ;
4533 int res1 = 0 ;
4534 PyObject *swig_obj[1] ;
4535
4536 if (!args) SWIG_fail;
4537 swig_obj[0] = args;
4538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4539 if (!SWIG_IsOK(res1)) {
4540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4541 }
4542 arg1 = reinterpret_cast< wxSize * >(argp1);
4543 result = (int) ((arg1)->y);
4544 resultobj = SWIG_From_int(static_cast< int >(result));
4545 return resultobj;
4546 fail:
4547 return NULL;
4548 }
4549
4550
4551 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4552 PyObject *resultobj = 0;
4553 int arg1 = (int) 0 ;
4554 int arg2 = (int) 0 ;
4555 wxSize *result = 0 ;
4556 int val1 ;
4557 int ecode1 = 0 ;
4558 int val2 ;
4559 int ecode2 = 0 ;
4560 PyObject * obj0 = 0 ;
4561 PyObject * obj1 = 0 ;
4562 char * kwnames[] = {
4563 (char *) "w",(char *) "h", NULL
4564 };
4565
4566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4567 if (obj0) {
4568 ecode1 = SWIG_AsVal_int(obj0, &val1);
4569 if (!SWIG_IsOK(ecode1)) {
4570 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4571 }
4572 arg1 = static_cast< int >(val1);
4573 }
4574 if (obj1) {
4575 ecode2 = SWIG_AsVal_int(obj1, &val2);
4576 if (!SWIG_IsOK(ecode2)) {
4577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4578 }
4579 arg2 = static_cast< int >(val2);
4580 }
4581 {
4582 PyThreadState* __tstate = wxPyBeginAllowThreads();
4583 result = (wxSize *)new wxSize(arg1,arg2);
4584 wxPyEndAllowThreads(__tstate);
4585 if (PyErr_Occurred()) SWIG_fail;
4586 }
4587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4588 return resultobj;
4589 fail:
4590 return NULL;
4591 }
4592
4593
4594 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4595 PyObject *resultobj = 0;
4596 wxSize *arg1 = (wxSize *) 0 ;
4597 void *argp1 = 0 ;
4598 int res1 = 0 ;
4599 PyObject *swig_obj[1] ;
4600
4601 if (!args) SWIG_fail;
4602 swig_obj[0] = args;
4603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4604 if (!SWIG_IsOK(res1)) {
4605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4606 }
4607 arg1 = reinterpret_cast< wxSize * >(argp1);
4608 {
4609 PyThreadState* __tstate = wxPyBeginAllowThreads();
4610 delete arg1;
4611
4612 wxPyEndAllowThreads(__tstate);
4613 if (PyErr_Occurred()) SWIG_fail;
4614 }
4615 resultobj = SWIG_Py_Void();
4616 return resultobj;
4617 fail:
4618 return NULL;
4619 }
4620
4621
4622 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4623 PyObject *resultobj = 0;
4624 wxSize *arg1 = (wxSize *) 0 ;
4625 PyObject *arg2 = (PyObject *) 0 ;
4626 bool result;
4627 void *argp1 = 0 ;
4628 int res1 = 0 ;
4629 PyObject * obj0 = 0 ;
4630 PyObject * obj1 = 0 ;
4631 char * kwnames[] = {
4632 (char *) "self",(char *) "other", NULL
4633 };
4634
4635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4637 if (!SWIG_IsOK(res1)) {
4638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4639 }
4640 arg1 = reinterpret_cast< wxSize * >(argp1);
4641 arg2 = obj1;
4642 {
4643 result = (bool)wxSize___eq__(arg1,arg2);
4644 if (PyErr_Occurred()) SWIG_fail;
4645 }
4646 {
4647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4648 }
4649 return resultobj;
4650 fail:
4651 return NULL;
4652 }
4653
4654
4655 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4656 PyObject *resultobj = 0;
4657 wxSize *arg1 = (wxSize *) 0 ;
4658 PyObject *arg2 = (PyObject *) 0 ;
4659 bool result;
4660 void *argp1 = 0 ;
4661 int res1 = 0 ;
4662 PyObject * obj0 = 0 ;
4663 PyObject * obj1 = 0 ;
4664 char * kwnames[] = {
4665 (char *) "self",(char *) "other", NULL
4666 };
4667
4668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4670 if (!SWIG_IsOK(res1)) {
4671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4672 }
4673 arg1 = reinterpret_cast< wxSize * >(argp1);
4674 arg2 = obj1;
4675 {
4676 result = (bool)wxSize___ne__(arg1,arg2);
4677 if (PyErr_Occurred()) SWIG_fail;
4678 }
4679 {
4680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4681 }
4682 return resultobj;
4683 fail:
4684 return NULL;
4685 }
4686
4687
4688 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4689 PyObject *resultobj = 0;
4690 wxSize *arg1 = (wxSize *) 0 ;
4691 wxSize *arg2 = 0 ;
4692 wxSize result;
4693 void *argp1 = 0 ;
4694 int res1 = 0 ;
4695 wxSize temp2 ;
4696 PyObject * obj0 = 0 ;
4697 PyObject * obj1 = 0 ;
4698 char * kwnames[] = {
4699 (char *) "self",(char *) "sz", NULL
4700 };
4701
4702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4704 if (!SWIG_IsOK(res1)) {
4705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4706 }
4707 arg1 = reinterpret_cast< wxSize * >(argp1);
4708 {
4709 arg2 = &temp2;
4710 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4711 }
4712 {
4713 PyThreadState* __tstate = wxPyBeginAllowThreads();
4714 result = (arg1)->operator +((wxSize const &)*arg2);
4715 wxPyEndAllowThreads(__tstate);
4716 if (PyErr_Occurred()) SWIG_fail;
4717 }
4718 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4719 return resultobj;
4720 fail:
4721 return NULL;
4722 }
4723
4724
4725 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4726 PyObject *resultobj = 0;
4727 wxSize *arg1 = (wxSize *) 0 ;
4728 wxSize *arg2 = 0 ;
4729 wxSize result;
4730 void *argp1 = 0 ;
4731 int res1 = 0 ;
4732 wxSize temp2 ;
4733 PyObject * obj0 = 0 ;
4734 PyObject * obj1 = 0 ;
4735 char * kwnames[] = {
4736 (char *) "self",(char *) "sz", NULL
4737 };
4738
4739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4741 if (!SWIG_IsOK(res1)) {
4742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4743 }
4744 arg1 = reinterpret_cast< wxSize * >(argp1);
4745 {
4746 arg2 = &temp2;
4747 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4748 }
4749 {
4750 PyThreadState* __tstate = wxPyBeginAllowThreads();
4751 result = (arg1)->operator -((wxSize const &)*arg2);
4752 wxPyEndAllowThreads(__tstate);
4753 if (PyErr_Occurred()) SWIG_fail;
4754 }
4755 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4756 return resultobj;
4757 fail:
4758 return NULL;
4759 }
4760
4761
4762 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4763 PyObject *resultobj = 0;
4764 wxSize *arg1 = (wxSize *) 0 ;
4765 wxSize *arg2 = 0 ;
4766 void *argp1 = 0 ;
4767 int res1 = 0 ;
4768 wxSize temp2 ;
4769 PyObject * obj0 = 0 ;
4770 PyObject * obj1 = 0 ;
4771 char * kwnames[] = {
4772 (char *) "self",(char *) "sz", NULL
4773 };
4774
4775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4777 if (!SWIG_IsOK(res1)) {
4778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4779 }
4780 arg1 = reinterpret_cast< wxSize * >(argp1);
4781 {
4782 arg2 = &temp2;
4783 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4784 }
4785 {
4786 PyThreadState* __tstate = wxPyBeginAllowThreads();
4787 (arg1)->IncTo((wxSize const &)*arg2);
4788 wxPyEndAllowThreads(__tstate);
4789 if (PyErr_Occurred()) SWIG_fail;
4790 }
4791 resultobj = SWIG_Py_Void();
4792 return resultobj;
4793 fail:
4794 return NULL;
4795 }
4796
4797
4798 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4799 PyObject *resultobj = 0;
4800 wxSize *arg1 = (wxSize *) 0 ;
4801 wxSize *arg2 = 0 ;
4802 void *argp1 = 0 ;
4803 int res1 = 0 ;
4804 wxSize temp2 ;
4805 PyObject * obj0 = 0 ;
4806 PyObject * obj1 = 0 ;
4807 char * kwnames[] = {
4808 (char *) "self",(char *) "sz", NULL
4809 };
4810
4811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4813 if (!SWIG_IsOK(res1)) {
4814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4815 }
4816 arg1 = reinterpret_cast< wxSize * >(argp1);
4817 {
4818 arg2 = &temp2;
4819 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4820 }
4821 {
4822 PyThreadState* __tstate = wxPyBeginAllowThreads();
4823 (arg1)->DecTo((wxSize const &)*arg2);
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 resultobj = SWIG_Py_Void();
4828 return resultobj;
4829 fail:
4830 return NULL;
4831 }
4832
4833
4834 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4835 PyObject *resultobj = 0;
4836 wxSize *arg1 = (wxSize *) 0 ;
4837 float arg2 ;
4838 float arg3 ;
4839 void *argp1 = 0 ;
4840 int res1 = 0 ;
4841 float val2 ;
4842 int ecode2 = 0 ;
4843 float val3 ;
4844 int ecode3 = 0 ;
4845 PyObject * obj0 = 0 ;
4846 PyObject * obj1 = 0 ;
4847 PyObject * obj2 = 0 ;
4848 char * kwnames[] = {
4849 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4850 };
4851
4852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4854 if (!SWIG_IsOK(res1)) {
4855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4856 }
4857 arg1 = reinterpret_cast< wxSize * >(argp1);
4858 ecode2 = SWIG_AsVal_float(obj1, &val2);
4859 if (!SWIG_IsOK(ecode2)) {
4860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4861 }
4862 arg2 = static_cast< float >(val2);
4863 ecode3 = SWIG_AsVal_float(obj2, &val3);
4864 if (!SWIG_IsOK(ecode3)) {
4865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4866 }
4867 arg3 = static_cast< float >(val3);
4868 {
4869 PyThreadState* __tstate = wxPyBeginAllowThreads();
4870 (arg1)->Scale(arg2,arg3);
4871 wxPyEndAllowThreads(__tstate);
4872 if (PyErr_Occurred()) SWIG_fail;
4873 }
4874 resultobj = SWIG_Py_Void();
4875 return resultobj;
4876 fail:
4877 return NULL;
4878 }
4879
4880
4881 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4882 PyObject *resultobj = 0;
4883 wxSize *arg1 = (wxSize *) 0 ;
4884 int arg2 ;
4885 int arg3 ;
4886 void *argp1 = 0 ;
4887 int res1 = 0 ;
4888 int val2 ;
4889 int ecode2 = 0 ;
4890 int val3 ;
4891 int ecode3 = 0 ;
4892 PyObject * obj0 = 0 ;
4893 PyObject * obj1 = 0 ;
4894 PyObject * obj2 = 0 ;
4895 char * kwnames[] = {
4896 (char *) "self",(char *) "w",(char *) "h", NULL
4897 };
4898
4899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4901 if (!SWIG_IsOK(res1)) {
4902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4903 }
4904 arg1 = reinterpret_cast< wxSize * >(argp1);
4905 ecode2 = SWIG_AsVal_int(obj1, &val2);
4906 if (!SWIG_IsOK(ecode2)) {
4907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4908 }
4909 arg2 = static_cast< int >(val2);
4910 ecode3 = SWIG_AsVal_int(obj2, &val3);
4911 if (!SWIG_IsOK(ecode3)) {
4912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4913 }
4914 arg3 = static_cast< int >(val3);
4915 {
4916 PyThreadState* __tstate = wxPyBeginAllowThreads();
4917 (arg1)->Set(arg2,arg3);
4918 wxPyEndAllowThreads(__tstate);
4919 if (PyErr_Occurred()) SWIG_fail;
4920 }
4921 resultobj = SWIG_Py_Void();
4922 return resultobj;
4923 fail:
4924 return NULL;
4925 }
4926
4927
4928 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4929 PyObject *resultobj = 0;
4930 wxSize *arg1 = (wxSize *) 0 ;
4931 int arg2 ;
4932 void *argp1 = 0 ;
4933 int res1 = 0 ;
4934 int val2 ;
4935 int ecode2 = 0 ;
4936 PyObject * obj0 = 0 ;
4937 PyObject * obj1 = 0 ;
4938 char * kwnames[] = {
4939 (char *) "self",(char *) "w", NULL
4940 };
4941
4942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4944 if (!SWIG_IsOK(res1)) {
4945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4946 }
4947 arg1 = reinterpret_cast< wxSize * >(argp1);
4948 ecode2 = SWIG_AsVal_int(obj1, &val2);
4949 if (!SWIG_IsOK(ecode2)) {
4950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4951 }
4952 arg2 = static_cast< int >(val2);
4953 {
4954 PyThreadState* __tstate = wxPyBeginAllowThreads();
4955 (arg1)->SetWidth(arg2);
4956 wxPyEndAllowThreads(__tstate);
4957 if (PyErr_Occurred()) SWIG_fail;
4958 }
4959 resultobj = SWIG_Py_Void();
4960 return resultobj;
4961 fail:
4962 return NULL;
4963 }
4964
4965
4966 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4967 PyObject *resultobj = 0;
4968 wxSize *arg1 = (wxSize *) 0 ;
4969 int arg2 ;
4970 void *argp1 = 0 ;
4971 int res1 = 0 ;
4972 int val2 ;
4973 int ecode2 = 0 ;
4974 PyObject * obj0 = 0 ;
4975 PyObject * obj1 = 0 ;
4976 char * kwnames[] = {
4977 (char *) "self",(char *) "h", NULL
4978 };
4979
4980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4982 if (!SWIG_IsOK(res1)) {
4983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4984 }
4985 arg1 = reinterpret_cast< wxSize * >(argp1);
4986 ecode2 = SWIG_AsVal_int(obj1, &val2);
4987 if (!SWIG_IsOK(ecode2)) {
4988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4989 }
4990 arg2 = static_cast< int >(val2);
4991 {
4992 PyThreadState* __tstate = wxPyBeginAllowThreads();
4993 (arg1)->SetHeight(arg2);
4994 wxPyEndAllowThreads(__tstate);
4995 if (PyErr_Occurred()) SWIG_fail;
4996 }
4997 resultobj = SWIG_Py_Void();
4998 return resultobj;
4999 fail:
5000 return NULL;
5001 }
5002
5003
5004 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5005 PyObject *resultobj = 0;
5006 wxSize *arg1 = (wxSize *) 0 ;
5007 int result;
5008 void *argp1 = 0 ;
5009 int res1 = 0 ;
5010 PyObject *swig_obj[1] ;
5011
5012 if (!args) SWIG_fail;
5013 swig_obj[0] = args;
5014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5015 if (!SWIG_IsOK(res1)) {
5016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5017 }
5018 arg1 = reinterpret_cast< wxSize * >(argp1);
5019 {
5020 PyThreadState* __tstate = wxPyBeginAllowThreads();
5021 result = (int)((wxSize const *)arg1)->GetWidth();
5022 wxPyEndAllowThreads(__tstate);
5023 if (PyErr_Occurred()) SWIG_fail;
5024 }
5025 resultobj = SWIG_From_int(static_cast< int >(result));
5026 return resultobj;
5027 fail:
5028 return NULL;
5029 }
5030
5031
5032 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5033 PyObject *resultobj = 0;
5034 wxSize *arg1 = (wxSize *) 0 ;
5035 int result;
5036 void *argp1 = 0 ;
5037 int res1 = 0 ;
5038 PyObject *swig_obj[1] ;
5039
5040 if (!args) SWIG_fail;
5041 swig_obj[0] = args;
5042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5043 if (!SWIG_IsOK(res1)) {
5044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5045 }
5046 arg1 = reinterpret_cast< wxSize * >(argp1);
5047 {
5048 PyThreadState* __tstate = wxPyBeginAllowThreads();
5049 result = (int)((wxSize const *)arg1)->GetHeight();
5050 wxPyEndAllowThreads(__tstate);
5051 if (PyErr_Occurred()) SWIG_fail;
5052 }
5053 resultobj = SWIG_From_int(static_cast< int >(result));
5054 return resultobj;
5055 fail:
5056 return NULL;
5057 }
5058
5059
5060 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5061 PyObject *resultobj = 0;
5062 wxSize *arg1 = (wxSize *) 0 ;
5063 bool result;
5064 void *argp1 = 0 ;
5065 int res1 = 0 ;
5066 PyObject *swig_obj[1] ;
5067
5068 if (!args) SWIG_fail;
5069 swig_obj[0] = args;
5070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5071 if (!SWIG_IsOK(res1)) {
5072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5073 }
5074 arg1 = reinterpret_cast< wxSize * >(argp1);
5075 {
5076 PyThreadState* __tstate = wxPyBeginAllowThreads();
5077 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5078 wxPyEndAllowThreads(__tstate);
5079 if (PyErr_Occurred()) SWIG_fail;
5080 }
5081 {
5082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5083 }
5084 return resultobj;
5085 fail:
5086 return NULL;
5087 }
5088
5089
5090 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5091 PyObject *resultobj = 0;
5092 wxSize *arg1 = (wxSize *) 0 ;
5093 wxSize *arg2 = 0 ;
5094 void *argp1 = 0 ;
5095 int res1 = 0 ;
5096 wxSize temp2 ;
5097 PyObject * obj0 = 0 ;
5098 PyObject * obj1 = 0 ;
5099 char * kwnames[] = {
5100 (char *) "self",(char *) "size", NULL
5101 };
5102
5103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5105 if (!SWIG_IsOK(res1)) {
5106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5107 }
5108 arg1 = reinterpret_cast< wxSize * >(argp1);
5109 {
5110 arg2 = &temp2;
5111 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5112 }
5113 {
5114 PyThreadState* __tstate = wxPyBeginAllowThreads();
5115 (arg1)->SetDefaults((wxSize const &)*arg2);
5116 wxPyEndAllowThreads(__tstate);
5117 if (PyErr_Occurred()) SWIG_fail;
5118 }
5119 resultobj = SWIG_Py_Void();
5120 return resultobj;
5121 fail:
5122 return NULL;
5123 }
5124
5125
5126 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5127 PyObject *resultobj = 0;
5128 wxSize *arg1 = (wxSize *) 0 ;
5129 PyObject *result = 0 ;
5130 void *argp1 = 0 ;
5131 int res1 = 0 ;
5132 PyObject *swig_obj[1] ;
5133
5134 if (!args) SWIG_fail;
5135 swig_obj[0] = args;
5136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5137 if (!SWIG_IsOK(res1)) {
5138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5139 }
5140 arg1 = reinterpret_cast< wxSize * >(argp1);
5141 {
5142 PyThreadState* __tstate = wxPyBeginAllowThreads();
5143 result = (PyObject *)wxSize_Get(arg1);
5144 wxPyEndAllowThreads(__tstate);
5145 if (PyErr_Occurred()) SWIG_fail;
5146 }
5147 resultobj = result;
5148 return resultobj;
5149 fail:
5150 return NULL;
5151 }
5152
5153
5154 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5155 PyObject *obj;
5156 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5157 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5158 return SWIG_Py_Void();
5159 }
5160
5161 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5162 return SWIG_Python_InitShadowInstance(args);
5163 }
5164
5165 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5166 PyObject *resultobj = 0;
5167 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5168 double arg2 ;
5169 void *argp1 = 0 ;
5170 int res1 = 0 ;
5171 double val2 ;
5172 int ecode2 = 0 ;
5173 PyObject *swig_obj[2] ;
5174
5175 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5177 if (!SWIG_IsOK(res1)) {
5178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5179 }
5180 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5181 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5182 if (!SWIG_IsOK(ecode2)) {
5183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5184 }
5185 arg2 = static_cast< double >(val2);
5186 if (arg1) (arg1)->x = arg2;
5187
5188 resultobj = SWIG_Py_Void();
5189 return resultobj;
5190 fail:
5191 return NULL;
5192 }
5193
5194
5195 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5196 PyObject *resultobj = 0;
5197 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5198 double result;
5199 void *argp1 = 0 ;
5200 int res1 = 0 ;
5201 PyObject *swig_obj[1] ;
5202
5203 if (!args) SWIG_fail;
5204 swig_obj[0] = args;
5205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5206 if (!SWIG_IsOK(res1)) {
5207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5208 }
5209 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5210 result = (double) ((arg1)->x);
5211 resultobj = SWIG_From_double(static_cast< double >(result));
5212 return resultobj;
5213 fail:
5214 return NULL;
5215 }
5216
5217
5218 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5219 PyObject *resultobj = 0;
5220 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5221 double arg2 ;
5222 void *argp1 = 0 ;
5223 int res1 = 0 ;
5224 double val2 ;
5225 int ecode2 = 0 ;
5226 PyObject *swig_obj[2] ;
5227
5228 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5230 if (!SWIG_IsOK(res1)) {
5231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5232 }
5233 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5234 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5235 if (!SWIG_IsOK(ecode2)) {
5236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5237 }
5238 arg2 = static_cast< double >(val2);
5239 if (arg1) (arg1)->y = arg2;
5240
5241 resultobj = SWIG_Py_Void();
5242 return resultobj;
5243 fail:
5244 return NULL;
5245 }
5246
5247
5248 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5249 PyObject *resultobj = 0;
5250 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5251 double result;
5252 void *argp1 = 0 ;
5253 int res1 = 0 ;
5254 PyObject *swig_obj[1] ;
5255
5256 if (!args) SWIG_fail;
5257 swig_obj[0] = args;
5258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5259 if (!SWIG_IsOK(res1)) {
5260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5261 }
5262 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5263 result = (double) ((arg1)->y);
5264 resultobj = SWIG_From_double(static_cast< double >(result));
5265 return resultobj;
5266 fail:
5267 return NULL;
5268 }
5269
5270
5271 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5272 PyObject *resultobj = 0;
5273 double arg1 = (double) 0.0 ;
5274 double arg2 = (double) 0.0 ;
5275 wxRealPoint *result = 0 ;
5276 double val1 ;
5277 int ecode1 = 0 ;
5278 double val2 ;
5279 int ecode2 = 0 ;
5280 PyObject * obj0 = 0 ;
5281 PyObject * obj1 = 0 ;
5282 char * kwnames[] = {
5283 (char *) "x",(char *) "y", NULL
5284 };
5285
5286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5287 if (obj0) {
5288 ecode1 = SWIG_AsVal_double(obj0, &val1);
5289 if (!SWIG_IsOK(ecode1)) {
5290 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5291 }
5292 arg1 = static_cast< double >(val1);
5293 }
5294 if (obj1) {
5295 ecode2 = SWIG_AsVal_double(obj1, &val2);
5296 if (!SWIG_IsOK(ecode2)) {
5297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5298 }
5299 arg2 = static_cast< double >(val2);
5300 }
5301 {
5302 PyThreadState* __tstate = wxPyBeginAllowThreads();
5303 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5304 wxPyEndAllowThreads(__tstate);
5305 if (PyErr_Occurred()) SWIG_fail;
5306 }
5307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5308 return resultobj;
5309 fail:
5310 return NULL;
5311 }
5312
5313
5314 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5315 PyObject *resultobj = 0;
5316 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5317 void *argp1 = 0 ;
5318 int res1 = 0 ;
5319 PyObject *swig_obj[1] ;
5320
5321 if (!args) SWIG_fail;
5322 swig_obj[0] = args;
5323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5324 if (!SWIG_IsOK(res1)) {
5325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5326 }
5327 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5328 {
5329 PyThreadState* __tstate = wxPyBeginAllowThreads();
5330 delete arg1;
5331
5332 wxPyEndAllowThreads(__tstate);
5333 if (PyErr_Occurred()) SWIG_fail;
5334 }
5335 resultobj = SWIG_Py_Void();
5336 return resultobj;
5337 fail:
5338 return NULL;
5339 }
5340
5341
5342 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5343 PyObject *resultobj = 0;
5344 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5345 PyObject *arg2 = (PyObject *) 0 ;
5346 bool result;
5347 void *argp1 = 0 ;
5348 int res1 = 0 ;
5349 PyObject * obj0 = 0 ;
5350 PyObject * obj1 = 0 ;
5351 char * kwnames[] = {
5352 (char *) "self",(char *) "other", NULL
5353 };
5354
5355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5357 if (!SWIG_IsOK(res1)) {
5358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5359 }
5360 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5361 arg2 = obj1;
5362 {
5363 result = (bool)wxRealPoint___eq__(arg1,arg2);
5364 if (PyErr_Occurred()) SWIG_fail;
5365 }
5366 {
5367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5368 }
5369 return resultobj;
5370 fail:
5371 return NULL;
5372 }
5373
5374
5375 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5376 PyObject *resultobj = 0;
5377 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5378 PyObject *arg2 = (PyObject *) 0 ;
5379 bool result;
5380 void *argp1 = 0 ;
5381 int res1 = 0 ;
5382 PyObject * obj0 = 0 ;
5383 PyObject * obj1 = 0 ;
5384 char * kwnames[] = {
5385 (char *) "self",(char *) "other", NULL
5386 };
5387
5388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5390 if (!SWIG_IsOK(res1)) {
5391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5392 }
5393 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5394 arg2 = obj1;
5395 {
5396 result = (bool)wxRealPoint___ne__(arg1,arg2);
5397 if (PyErr_Occurred()) SWIG_fail;
5398 }
5399 {
5400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5401 }
5402 return resultobj;
5403 fail:
5404 return NULL;
5405 }
5406
5407
5408 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5409 PyObject *resultobj = 0;
5410 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5411 wxRealPoint *arg2 = 0 ;
5412 wxRealPoint result;
5413 void *argp1 = 0 ;
5414 int res1 = 0 ;
5415 wxRealPoint temp2 ;
5416 PyObject * obj0 = 0 ;
5417 PyObject * obj1 = 0 ;
5418 char * kwnames[] = {
5419 (char *) "self",(char *) "pt", NULL
5420 };
5421
5422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5424 if (!SWIG_IsOK(res1)) {
5425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5426 }
5427 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5428 {
5429 arg2 = &temp2;
5430 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5431 }
5432 {
5433 PyThreadState* __tstate = wxPyBeginAllowThreads();
5434 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5435 wxPyEndAllowThreads(__tstate);
5436 if (PyErr_Occurred()) SWIG_fail;
5437 }
5438 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5439 return resultobj;
5440 fail:
5441 return NULL;
5442 }
5443
5444
5445 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5446 PyObject *resultobj = 0;
5447 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5448 wxRealPoint *arg2 = 0 ;
5449 wxRealPoint result;
5450 void *argp1 = 0 ;
5451 int res1 = 0 ;
5452 wxRealPoint temp2 ;
5453 PyObject * obj0 = 0 ;
5454 PyObject * obj1 = 0 ;
5455 char * kwnames[] = {
5456 (char *) "self",(char *) "pt", NULL
5457 };
5458
5459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5461 if (!SWIG_IsOK(res1)) {
5462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5463 }
5464 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5465 {
5466 arg2 = &temp2;
5467 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5468 }
5469 {
5470 PyThreadState* __tstate = wxPyBeginAllowThreads();
5471 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5472 wxPyEndAllowThreads(__tstate);
5473 if (PyErr_Occurred()) SWIG_fail;
5474 }
5475 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5476 return resultobj;
5477 fail:
5478 return NULL;
5479 }
5480
5481
5482 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5483 PyObject *resultobj = 0;
5484 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5485 double arg2 ;
5486 double arg3 ;
5487 void *argp1 = 0 ;
5488 int res1 = 0 ;
5489 double val2 ;
5490 int ecode2 = 0 ;
5491 double val3 ;
5492 int ecode3 = 0 ;
5493 PyObject * obj0 = 0 ;
5494 PyObject * obj1 = 0 ;
5495 PyObject * obj2 = 0 ;
5496 char * kwnames[] = {
5497 (char *) "self",(char *) "x",(char *) "y", NULL
5498 };
5499
5500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5502 if (!SWIG_IsOK(res1)) {
5503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5504 }
5505 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5506 ecode2 = SWIG_AsVal_double(obj1, &val2);
5507 if (!SWIG_IsOK(ecode2)) {
5508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5509 }
5510 arg2 = static_cast< double >(val2);
5511 ecode3 = SWIG_AsVal_double(obj2, &val3);
5512 if (!SWIG_IsOK(ecode3)) {
5513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5514 }
5515 arg3 = static_cast< double >(val3);
5516 {
5517 PyThreadState* __tstate = wxPyBeginAllowThreads();
5518 wxRealPoint_Set(arg1,arg2,arg3);
5519 wxPyEndAllowThreads(__tstate);
5520 if (PyErr_Occurred()) SWIG_fail;
5521 }
5522 resultobj = SWIG_Py_Void();
5523 return resultobj;
5524 fail:
5525 return NULL;
5526 }
5527
5528
5529 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5530 PyObject *resultobj = 0;
5531 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5532 PyObject *result = 0 ;
5533 void *argp1 = 0 ;
5534 int res1 = 0 ;
5535 PyObject *swig_obj[1] ;
5536
5537 if (!args) SWIG_fail;
5538 swig_obj[0] = args;
5539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5540 if (!SWIG_IsOK(res1)) {
5541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5542 }
5543 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5544 {
5545 PyThreadState* __tstate = wxPyBeginAllowThreads();
5546 result = (PyObject *)wxRealPoint_Get(arg1);
5547 wxPyEndAllowThreads(__tstate);
5548 if (PyErr_Occurred()) SWIG_fail;
5549 }
5550 resultobj = result;
5551 return resultobj;
5552 fail:
5553 return NULL;
5554 }
5555
5556
5557 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5558 PyObject *obj;
5559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5560 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5561 return SWIG_Py_Void();
5562 }
5563
5564 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5565 return SWIG_Python_InitShadowInstance(args);
5566 }
5567
5568 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5569 PyObject *resultobj = 0;
5570 wxPoint *arg1 = (wxPoint *) 0 ;
5571 int arg2 ;
5572 void *argp1 = 0 ;
5573 int res1 = 0 ;
5574 int val2 ;
5575 int ecode2 = 0 ;
5576 PyObject *swig_obj[2] ;
5577
5578 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5580 if (!SWIG_IsOK(res1)) {
5581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5582 }
5583 arg1 = reinterpret_cast< wxPoint * >(argp1);
5584 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5585 if (!SWIG_IsOK(ecode2)) {
5586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5587 }
5588 arg2 = static_cast< int >(val2);
5589 if (arg1) (arg1)->x = arg2;
5590
5591 resultobj = SWIG_Py_Void();
5592 return resultobj;
5593 fail:
5594 return NULL;
5595 }
5596
5597
5598 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5599 PyObject *resultobj = 0;
5600 wxPoint *arg1 = (wxPoint *) 0 ;
5601 int result;
5602 void *argp1 = 0 ;
5603 int res1 = 0 ;
5604 PyObject *swig_obj[1] ;
5605
5606 if (!args) SWIG_fail;
5607 swig_obj[0] = args;
5608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5609 if (!SWIG_IsOK(res1)) {
5610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5611 }
5612 arg1 = reinterpret_cast< wxPoint * >(argp1);
5613 result = (int) ((arg1)->x);
5614 resultobj = SWIG_From_int(static_cast< int >(result));
5615 return resultobj;
5616 fail:
5617 return NULL;
5618 }
5619
5620
5621 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5622 PyObject *resultobj = 0;
5623 wxPoint *arg1 = (wxPoint *) 0 ;
5624 int arg2 ;
5625 void *argp1 = 0 ;
5626 int res1 = 0 ;
5627 int val2 ;
5628 int ecode2 = 0 ;
5629 PyObject *swig_obj[2] ;
5630
5631 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5633 if (!SWIG_IsOK(res1)) {
5634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5635 }
5636 arg1 = reinterpret_cast< wxPoint * >(argp1);
5637 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5638 if (!SWIG_IsOK(ecode2)) {
5639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5640 }
5641 arg2 = static_cast< int >(val2);
5642 if (arg1) (arg1)->y = arg2;
5643
5644 resultobj = SWIG_Py_Void();
5645 return resultobj;
5646 fail:
5647 return NULL;
5648 }
5649
5650
5651 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5652 PyObject *resultobj = 0;
5653 wxPoint *arg1 = (wxPoint *) 0 ;
5654 int result;
5655 void *argp1 = 0 ;
5656 int res1 = 0 ;
5657 PyObject *swig_obj[1] ;
5658
5659 if (!args) SWIG_fail;
5660 swig_obj[0] = args;
5661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5662 if (!SWIG_IsOK(res1)) {
5663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5664 }
5665 arg1 = reinterpret_cast< wxPoint * >(argp1);
5666 result = (int) ((arg1)->y);
5667 resultobj = SWIG_From_int(static_cast< int >(result));
5668 return resultobj;
5669 fail:
5670 return NULL;
5671 }
5672
5673
5674 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5675 PyObject *resultobj = 0;
5676 int arg1 = (int) 0 ;
5677 int arg2 = (int) 0 ;
5678 wxPoint *result = 0 ;
5679 int val1 ;
5680 int ecode1 = 0 ;
5681 int val2 ;
5682 int ecode2 = 0 ;
5683 PyObject * obj0 = 0 ;
5684 PyObject * obj1 = 0 ;
5685 char * kwnames[] = {
5686 (char *) "x",(char *) "y", NULL
5687 };
5688
5689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5690 if (obj0) {
5691 ecode1 = SWIG_AsVal_int(obj0, &val1);
5692 if (!SWIG_IsOK(ecode1)) {
5693 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5694 }
5695 arg1 = static_cast< int >(val1);
5696 }
5697 if (obj1) {
5698 ecode2 = SWIG_AsVal_int(obj1, &val2);
5699 if (!SWIG_IsOK(ecode2)) {
5700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5701 }
5702 arg2 = static_cast< int >(val2);
5703 }
5704 {
5705 PyThreadState* __tstate = wxPyBeginAllowThreads();
5706 result = (wxPoint *)new wxPoint(arg1,arg2);
5707 wxPyEndAllowThreads(__tstate);
5708 if (PyErr_Occurred()) SWIG_fail;
5709 }
5710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5711 return resultobj;
5712 fail:
5713 return NULL;
5714 }
5715
5716
5717 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5718 PyObject *resultobj = 0;
5719 wxPoint *arg1 = (wxPoint *) 0 ;
5720 void *argp1 = 0 ;
5721 int res1 = 0 ;
5722 PyObject *swig_obj[1] ;
5723
5724 if (!args) SWIG_fail;
5725 swig_obj[0] = args;
5726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5727 if (!SWIG_IsOK(res1)) {
5728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5729 }
5730 arg1 = reinterpret_cast< wxPoint * >(argp1);
5731 {
5732 PyThreadState* __tstate = wxPyBeginAllowThreads();
5733 delete arg1;
5734
5735 wxPyEndAllowThreads(__tstate);
5736 if (PyErr_Occurred()) SWIG_fail;
5737 }
5738 resultobj = SWIG_Py_Void();
5739 return resultobj;
5740 fail:
5741 return NULL;
5742 }
5743
5744
5745 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5746 PyObject *resultobj = 0;
5747 wxPoint *arg1 = (wxPoint *) 0 ;
5748 PyObject *arg2 = (PyObject *) 0 ;
5749 bool result;
5750 void *argp1 = 0 ;
5751 int res1 = 0 ;
5752 PyObject * obj0 = 0 ;
5753 PyObject * obj1 = 0 ;
5754 char * kwnames[] = {
5755 (char *) "self",(char *) "other", NULL
5756 };
5757
5758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5760 if (!SWIG_IsOK(res1)) {
5761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5762 }
5763 arg1 = reinterpret_cast< wxPoint * >(argp1);
5764 arg2 = obj1;
5765 {
5766 result = (bool)wxPoint___eq__(arg1,arg2);
5767 if (PyErr_Occurred()) SWIG_fail;
5768 }
5769 {
5770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5771 }
5772 return resultobj;
5773 fail:
5774 return NULL;
5775 }
5776
5777
5778 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5779 PyObject *resultobj = 0;
5780 wxPoint *arg1 = (wxPoint *) 0 ;
5781 PyObject *arg2 = (PyObject *) 0 ;
5782 bool result;
5783 void *argp1 = 0 ;
5784 int res1 = 0 ;
5785 PyObject * obj0 = 0 ;
5786 PyObject * obj1 = 0 ;
5787 char * kwnames[] = {
5788 (char *) "self",(char *) "other", NULL
5789 };
5790
5791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5793 if (!SWIG_IsOK(res1)) {
5794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5795 }
5796 arg1 = reinterpret_cast< wxPoint * >(argp1);
5797 arg2 = obj1;
5798 {
5799 result = (bool)wxPoint___ne__(arg1,arg2);
5800 if (PyErr_Occurred()) SWIG_fail;
5801 }
5802 {
5803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5804 }
5805 return resultobj;
5806 fail:
5807 return NULL;
5808 }
5809
5810
5811 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5812 PyObject *resultobj = 0;
5813 wxPoint *arg1 = (wxPoint *) 0 ;
5814 wxPoint *arg2 = 0 ;
5815 wxPoint result;
5816 void *argp1 = 0 ;
5817 int res1 = 0 ;
5818 wxPoint temp2 ;
5819 PyObject * obj0 = 0 ;
5820 PyObject * obj1 = 0 ;
5821 char * kwnames[] = {
5822 (char *) "self",(char *) "pt", NULL
5823 };
5824
5825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5827 if (!SWIG_IsOK(res1)) {
5828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5829 }
5830 arg1 = reinterpret_cast< wxPoint * >(argp1);
5831 {
5832 arg2 = &temp2;
5833 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5834 }
5835 {
5836 PyThreadState* __tstate = wxPyBeginAllowThreads();
5837 result = (arg1)->operator +((wxPoint const &)*arg2);
5838 wxPyEndAllowThreads(__tstate);
5839 if (PyErr_Occurred()) SWIG_fail;
5840 }
5841 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5842 return resultobj;
5843 fail:
5844 return NULL;
5845 }
5846
5847
5848 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5849 PyObject *resultobj = 0;
5850 wxPoint *arg1 = (wxPoint *) 0 ;
5851 wxPoint *arg2 = 0 ;
5852 wxPoint result;
5853 void *argp1 = 0 ;
5854 int res1 = 0 ;
5855 wxPoint temp2 ;
5856 PyObject * obj0 = 0 ;
5857 PyObject * obj1 = 0 ;
5858 char * kwnames[] = {
5859 (char *) "self",(char *) "pt", NULL
5860 };
5861
5862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5864 if (!SWIG_IsOK(res1)) {
5865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5866 }
5867 arg1 = reinterpret_cast< wxPoint * >(argp1);
5868 {
5869 arg2 = &temp2;
5870 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5871 }
5872 {
5873 PyThreadState* __tstate = wxPyBeginAllowThreads();
5874 result = (arg1)->operator -((wxPoint const &)*arg2);
5875 wxPyEndAllowThreads(__tstate);
5876 if (PyErr_Occurred()) SWIG_fail;
5877 }
5878 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5879 return resultobj;
5880 fail:
5881 return NULL;
5882 }
5883
5884
5885 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5886 PyObject *resultobj = 0;
5887 wxPoint *arg1 = (wxPoint *) 0 ;
5888 wxPoint *arg2 = 0 ;
5889 wxPoint *result = 0 ;
5890 void *argp1 = 0 ;
5891 int res1 = 0 ;
5892 wxPoint temp2 ;
5893 PyObject * obj0 = 0 ;
5894 PyObject * obj1 = 0 ;
5895 char * kwnames[] = {
5896 (char *) "self",(char *) "pt", NULL
5897 };
5898
5899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5901 if (!SWIG_IsOK(res1)) {
5902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5903 }
5904 arg1 = reinterpret_cast< wxPoint * >(argp1);
5905 {
5906 arg2 = &temp2;
5907 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5908 }
5909 {
5910 PyThreadState* __tstate = wxPyBeginAllowThreads();
5911 {
5912 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5913 result = (wxPoint *) &_result_ref;
5914 }
5915 wxPyEndAllowThreads(__tstate);
5916 if (PyErr_Occurred()) SWIG_fail;
5917 }
5918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5919 return resultobj;
5920 fail:
5921 return NULL;
5922 }
5923
5924
5925 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5926 PyObject *resultobj = 0;
5927 wxPoint *arg1 = (wxPoint *) 0 ;
5928 wxPoint *arg2 = 0 ;
5929 wxPoint *result = 0 ;
5930 void *argp1 = 0 ;
5931 int res1 = 0 ;
5932 wxPoint temp2 ;
5933 PyObject * obj0 = 0 ;
5934 PyObject * obj1 = 0 ;
5935 char * kwnames[] = {
5936 (char *) "self",(char *) "pt", NULL
5937 };
5938
5939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5941 if (!SWIG_IsOK(res1)) {
5942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5943 }
5944 arg1 = reinterpret_cast< wxPoint * >(argp1);
5945 {
5946 arg2 = &temp2;
5947 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5948 }
5949 {
5950 PyThreadState* __tstate = wxPyBeginAllowThreads();
5951 {
5952 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5953 result = (wxPoint *) &_result_ref;
5954 }
5955 wxPyEndAllowThreads(__tstate);
5956 if (PyErr_Occurred()) SWIG_fail;
5957 }
5958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5959 return resultobj;
5960 fail:
5961 return NULL;
5962 }
5963
5964
5965 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5966 PyObject *resultobj = 0;
5967 wxPoint *arg1 = (wxPoint *) 0 ;
5968 long arg2 ;
5969 long arg3 ;
5970 void *argp1 = 0 ;
5971 int res1 = 0 ;
5972 long val2 ;
5973 int ecode2 = 0 ;
5974 long val3 ;
5975 int ecode3 = 0 ;
5976 PyObject * obj0 = 0 ;
5977 PyObject * obj1 = 0 ;
5978 PyObject * obj2 = 0 ;
5979 char * kwnames[] = {
5980 (char *) "self",(char *) "x",(char *) "y", NULL
5981 };
5982
5983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5985 if (!SWIG_IsOK(res1)) {
5986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5987 }
5988 arg1 = reinterpret_cast< wxPoint * >(argp1);
5989 ecode2 = SWIG_AsVal_long(obj1, &val2);
5990 if (!SWIG_IsOK(ecode2)) {
5991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5992 }
5993 arg2 = static_cast< long >(val2);
5994 ecode3 = SWIG_AsVal_long(obj2, &val3);
5995 if (!SWIG_IsOK(ecode3)) {
5996 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5997 }
5998 arg3 = static_cast< long >(val3);
5999 {
6000 PyThreadState* __tstate = wxPyBeginAllowThreads();
6001 wxPoint_Set(arg1,arg2,arg3);
6002 wxPyEndAllowThreads(__tstate);
6003 if (PyErr_Occurred()) SWIG_fail;
6004 }
6005 resultobj = SWIG_Py_Void();
6006 return resultobj;
6007 fail:
6008 return NULL;
6009 }
6010
6011
6012 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6013 PyObject *resultobj = 0;
6014 wxPoint *arg1 = (wxPoint *) 0 ;
6015 PyObject *result = 0 ;
6016 void *argp1 = 0 ;
6017 int res1 = 0 ;
6018 PyObject *swig_obj[1] ;
6019
6020 if (!args) SWIG_fail;
6021 swig_obj[0] = args;
6022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6023 if (!SWIG_IsOK(res1)) {
6024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6025 }
6026 arg1 = reinterpret_cast< wxPoint * >(argp1);
6027 {
6028 PyThreadState* __tstate = wxPyBeginAllowThreads();
6029 result = (PyObject *)wxPoint_Get(arg1);
6030 wxPyEndAllowThreads(__tstate);
6031 if (PyErr_Occurred()) SWIG_fail;
6032 }
6033 resultobj = result;
6034 return resultobj;
6035 fail:
6036 return NULL;
6037 }
6038
6039
6040 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6041 PyObject *obj;
6042 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6043 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6044 return SWIG_Py_Void();
6045 }
6046
6047 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6048 return SWIG_Python_InitShadowInstance(args);
6049 }
6050
6051 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6052 PyObject *resultobj = 0;
6053 int arg1 = (int) 0 ;
6054 int arg2 = (int) 0 ;
6055 int arg3 = (int) 0 ;
6056 int arg4 = (int) 0 ;
6057 wxRect *result = 0 ;
6058 int val1 ;
6059 int ecode1 = 0 ;
6060 int val2 ;
6061 int ecode2 = 0 ;
6062 int val3 ;
6063 int ecode3 = 0 ;
6064 int val4 ;
6065 int ecode4 = 0 ;
6066 PyObject * obj0 = 0 ;
6067 PyObject * obj1 = 0 ;
6068 PyObject * obj2 = 0 ;
6069 PyObject * obj3 = 0 ;
6070 char * kwnames[] = {
6071 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6072 };
6073
6074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6075 if (obj0) {
6076 ecode1 = SWIG_AsVal_int(obj0, &val1);
6077 if (!SWIG_IsOK(ecode1)) {
6078 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6079 }
6080 arg1 = static_cast< int >(val1);
6081 }
6082 if (obj1) {
6083 ecode2 = SWIG_AsVal_int(obj1, &val2);
6084 if (!SWIG_IsOK(ecode2)) {
6085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6086 }
6087 arg2 = static_cast< int >(val2);
6088 }
6089 if (obj2) {
6090 ecode3 = SWIG_AsVal_int(obj2, &val3);
6091 if (!SWIG_IsOK(ecode3)) {
6092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6093 }
6094 arg3 = static_cast< int >(val3);
6095 }
6096 if (obj3) {
6097 ecode4 = SWIG_AsVal_int(obj3, &val4);
6098 if (!SWIG_IsOK(ecode4)) {
6099 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6100 }
6101 arg4 = static_cast< int >(val4);
6102 }
6103 {
6104 PyThreadState* __tstate = wxPyBeginAllowThreads();
6105 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6106 wxPyEndAllowThreads(__tstate);
6107 if (PyErr_Occurred()) SWIG_fail;
6108 }
6109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6110 return resultobj;
6111 fail:
6112 return NULL;
6113 }
6114
6115
6116 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6117 PyObject *resultobj = 0;
6118 wxPoint *arg1 = 0 ;
6119 wxPoint *arg2 = 0 ;
6120 wxRect *result = 0 ;
6121 wxPoint temp1 ;
6122 wxPoint temp2 ;
6123 PyObject * obj0 = 0 ;
6124 PyObject * obj1 = 0 ;
6125 char * kwnames[] = {
6126 (char *) "topLeft",(char *) "bottomRight", NULL
6127 };
6128
6129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6130 {
6131 arg1 = &temp1;
6132 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6133 }
6134 {
6135 arg2 = &temp2;
6136 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6137 }
6138 {
6139 PyThreadState* __tstate = wxPyBeginAllowThreads();
6140 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6141 wxPyEndAllowThreads(__tstate);
6142 if (PyErr_Occurred()) SWIG_fail;
6143 }
6144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6145 return resultobj;
6146 fail:
6147 return NULL;
6148 }
6149
6150
6151 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6152 PyObject *resultobj = 0;
6153 wxPoint *arg1 = 0 ;
6154 wxSize *arg2 = 0 ;
6155 wxRect *result = 0 ;
6156 wxPoint temp1 ;
6157 wxSize temp2 ;
6158 PyObject * obj0 = 0 ;
6159 PyObject * obj1 = 0 ;
6160 char * kwnames[] = {
6161 (char *) "pos",(char *) "size", NULL
6162 };
6163
6164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6165 {
6166 arg1 = &temp1;
6167 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6168 }
6169 {
6170 arg2 = &temp2;
6171 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6172 }
6173 {
6174 PyThreadState* __tstate = wxPyBeginAllowThreads();
6175 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize 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_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6187 PyObject *resultobj = 0;
6188 wxSize *arg1 = 0 ;
6189 wxRect *result = 0 ;
6190 wxSize temp1 ;
6191 PyObject * obj0 = 0 ;
6192 char * kwnames[] = {
6193 (char *) "size", NULL
6194 };
6195
6196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6197 {
6198 arg1 = &temp1;
6199 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6200 }
6201 {
6202 PyThreadState* __tstate = wxPyBeginAllowThreads();
6203 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6204 wxPyEndAllowThreads(__tstate);
6205 if (PyErr_Occurred()) SWIG_fail;
6206 }
6207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6208 return resultobj;
6209 fail:
6210 return NULL;
6211 }
6212
6213
6214 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6215 PyObject *resultobj = 0;
6216 wxRect *arg1 = (wxRect *) 0 ;
6217 void *argp1 = 0 ;
6218 int res1 = 0 ;
6219 PyObject *swig_obj[1] ;
6220
6221 if (!args) SWIG_fail;
6222 swig_obj[0] = args;
6223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6224 if (!SWIG_IsOK(res1)) {
6225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6226 }
6227 arg1 = reinterpret_cast< wxRect * >(argp1);
6228 {
6229 PyThreadState* __tstate = wxPyBeginAllowThreads();
6230 delete arg1;
6231
6232 wxPyEndAllowThreads(__tstate);
6233 if (PyErr_Occurred()) SWIG_fail;
6234 }
6235 resultobj = SWIG_Py_Void();
6236 return resultobj;
6237 fail:
6238 return NULL;
6239 }
6240
6241
6242 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6243 PyObject *resultobj = 0;
6244 wxRect *arg1 = (wxRect *) 0 ;
6245 int result;
6246 void *argp1 = 0 ;
6247 int res1 = 0 ;
6248 PyObject *swig_obj[1] ;
6249
6250 if (!args) SWIG_fail;
6251 swig_obj[0] = args;
6252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6253 if (!SWIG_IsOK(res1)) {
6254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6255 }
6256 arg1 = reinterpret_cast< wxRect * >(argp1);
6257 {
6258 PyThreadState* __tstate = wxPyBeginAllowThreads();
6259 result = (int)((wxRect const *)arg1)->GetX();
6260 wxPyEndAllowThreads(__tstate);
6261 if (PyErr_Occurred()) SWIG_fail;
6262 }
6263 resultobj = SWIG_From_int(static_cast< int >(result));
6264 return resultobj;
6265 fail:
6266 return NULL;
6267 }
6268
6269
6270 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6271 PyObject *resultobj = 0;
6272 wxRect *arg1 = (wxRect *) 0 ;
6273 int arg2 ;
6274 void *argp1 = 0 ;
6275 int res1 = 0 ;
6276 int val2 ;
6277 int ecode2 = 0 ;
6278 PyObject * obj0 = 0 ;
6279 PyObject * obj1 = 0 ;
6280 char * kwnames[] = {
6281 (char *) "self",(char *) "x", NULL
6282 };
6283
6284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6286 if (!SWIG_IsOK(res1)) {
6287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6288 }
6289 arg1 = reinterpret_cast< wxRect * >(argp1);
6290 ecode2 = SWIG_AsVal_int(obj1, &val2);
6291 if (!SWIG_IsOK(ecode2)) {
6292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6293 }
6294 arg2 = static_cast< int >(val2);
6295 {
6296 PyThreadState* __tstate = wxPyBeginAllowThreads();
6297 (arg1)->SetX(arg2);
6298 wxPyEndAllowThreads(__tstate);
6299 if (PyErr_Occurred()) SWIG_fail;
6300 }
6301 resultobj = SWIG_Py_Void();
6302 return resultobj;
6303 fail:
6304 return NULL;
6305 }
6306
6307
6308 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6309 PyObject *resultobj = 0;
6310 wxRect *arg1 = (wxRect *) 0 ;
6311 int result;
6312 void *argp1 = 0 ;
6313 int res1 = 0 ;
6314 PyObject *swig_obj[1] ;
6315
6316 if (!args) SWIG_fail;
6317 swig_obj[0] = args;
6318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6319 if (!SWIG_IsOK(res1)) {
6320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6321 }
6322 arg1 = reinterpret_cast< wxRect * >(argp1);
6323 {
6324 PyThreadState* __tstate = wxPyBeginAllowThreads();
6325 result = (int)(arg1)->GetY();
6326 wxPyEndAllowThreads(__tstate);
6327 if (PyErr_Occurred()) SWIG_fail;
6328 }
6329 resultobj = SWIG_From_int(static_cast< int >(result));
6330 return resultobj;
6331 fail:
6332 return NULL;
6333 }
6334
6335
6336 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6337 PyObject *resultobj = 0;
6338 wxRect *arg1 = (wxRect *) 0 ;
6339 int arg2 ;
6340 void *argp1 = 0 ;
6341 int res1 = 0 ;
6342 int val2 ;
6343 int ecode2 = 0 ;
6344 PyObject * obj0 = 0 ;
6345 PyObject * obj1 = 0 ;
6346 char * kwnames[] = {
6347 (char *) "self",(char *) "y", NULL
6348 };
6349
6350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6352 if (!SWIG_IsOK(res1)) {
6353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6354 }
6355 arg1 = reinterpret_cast< wxRect * >(argp1);
6356 ecode2 = SWIG_AsVal_int(obj1, &val2);
6357 if (!SWIG_IsOK(ecode2)) {
6358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6359 }
6360 arg2 = static_cast< int >(val2);
6361 {
6362 PyThreadState* __tstate = wxPyBeginAllowThreads();
6363 (arg1)->SetY(arg2);
6364 wxPyEndAllowThreads(__tstate);
6365 if (PyErr_Occurred()) SWIG_fail;
6366 }
6367 resultobj = SWIG_Py_Void();
6368 return resultobj;
6369 fail:
6370 return NULL;
6371 }
6372
6373
6374 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6375 PyObject *resultobj = 0;
6376 wxRect *arg1 = (wxRect *) 0 ;
6377 int result;
6378 void *argp1 = 0 ;
6379 int res1 = 0 ;
6380 PyObject *swig_obj[1] ;
6381
6382 if (!args) SWIG_fail;
6383 swig_obj[0] = args;
6384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6385 if (!SWIG_IsOK(res1)) {
6386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6387 }
6388 arg1 = reinterpret_cast< wxRect * >(argp1);
6389 {
6390 PyThreadState* __tstate = wxPyBeginAllowThreads();
6391 result = (int)((wxRect const *)arg1)->GetWidth();
6392 wxPyEndAllowThreads(__tstate);
6393 if (PyErr_Occurred()) SWIG_fail;
6394 }
6395 resultobj = SWIG_From_int(static_cast< int >(result));
6396 return resultobj;
6397 fail:
6398 return NULL;
6399 }
6400
6401
6402 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6403 PyObject *resultobj = 0;
6404 wxRect *arg1 = (wxRect *) 0 ;
6405 int arg2 ;
6406 void *argp1 = 0 ;
6407 int res1 = 0 ;
6408 int val2 ;
6409 int ecode2 = 0 ;
6410 PyObject * obj0 = 0 ;
6411 PyObject * obj1 = 0 ;
6412 char * kwnames[] = {
6413 (char *) "self",(char *) "w", NULL
6414 };
6415
6416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6418 if (!SWIG_IsOK(res1)) {
6419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6420 }
6421 arg1 = reinterpret_cast< wxRect * >(argp1);
6422 ecode2 = SWIG_AsVal_int(obj1, &val2);
6423 if (!SWIG_IsOK(ecode2)) {
6424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6425 }
6426 arg2 = static_cast< int >(val2);
6427 {
6428 PyThreadState* __tstate = wxPyBeginAllowThreads();
6429 (arg1)->SetWidth(arg2);
6430 wxPyEndAllowThreads(__tstate);
6431 if (PyErr_Occurred()) SWIG_fail;
6432 }
6433 resultobj = SWIG_Py_Void();
6434 return resultobj;
6435 fail:
6436 return NULL;
6437 }
6438
6439
6440 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6441 PyObject *resultobj = 0;
6442 wxRect *arg1 = (wxRect *) 0 ;
6443 int result;
6444 void *argp1 = 0 ;
6445 int res1 = 0 ;
6446 PyObject *swig_obj[1] ;
6447
6448 if (!args) SWIG_fail;
6449 swig_obj[0] = args;
6450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6451 if (!SWIG_IsOK(res1)) {
6452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6453 }
6454 arg1 = reinterpret_cast< wxRect * >(argp1);
6455 {
6456 PyThreadState* __tstate = wxPyBeginAllowThreads();
6457 result = (int)((wxRect const *)arg1)->GetHeight();
6458 wxPyEndAllowThreads(__tstate);
6459 if (PyErr_Occurred()) SWIG_fail;
6460 }
6461 resultobj = SWIG_From_int(static_cast< int >(result));
6462 return resultobj;
6463 fail:
6464 return NULL;
6465 }
6466
6467
6468 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6469 PyObject *resultobj = 0;
6470 wxRect *arg1 = (wxRect *) 0 ;
6471 int arg2 ;
6472 void *argp1 = 0 ;
6473 int res1 = 0 ;
6474 int val2 ;
6475 int ecode2 = 0 ;
6476 PyObject * obj0 = 0 ;
6477 PyObject * obj1 = 0 ;
6478 char * kwnames[] = {
6479 (char *) "self",(char *) "h", NULL
6480 };
6481
6482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6484 if (!SWIG_IsOK(res1)) {
6485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6486 }
6487 arg1 = reinterpret_cast< wxRect * >(argp1);
6488 ecode2 = SWIG_AsVal_int(obj1, &val2);
6489 if (!SWIG_IsOK(ecode2)) {
6490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6491 }
6492 arg2 = static_cast< int >(val2);
6493 {
6494 PyThreadState* __tstate = wxPyBeginAllowThreads();
6495 (arg1)->SetHeight(arg2);
6496 wxPyEndAllowThreads(__tstate);
6497 if (PyErr_Occurred()) SWIG_fail;
6498 }
6499 resultobj = SWIG_Py_Void();
6500 return resultobj;
6501 fail:
6502 return NULL;
6503 }
6504
6505
6506 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6507 PyObject *resultobj = 0;
6508 wxRect *arg1 = (wxRect *) 0 ;
6509 wxPoint result;
6510 void *argp1 = 0 ;
6511 int res1 = 0 ;
6512 PyObject *swig_obj[1] ;
6513
6514 if (!args) SWIG_fail;
6515 swig_obj[0] = args;
6516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6517 if (!SWIG_IsOK(res1)) {
6518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6519 }
6520 arg1 = reinterpret_cast< wxRect * >(argp1);
6521 {
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 result = ((wxRect const *)arg1)->GetPosition();
6524 wxPyEndAllowThreads(__tstate);
6525 if (PyErr_Occurred()) SWIG_fail;
6526 }
6527 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6528 return resultobj;
6529 fail:
6530 return NULL;
6531 }
6532
6533
6534 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6535 PyObject *resultobj = 0;
6536 wxRect *arg1 = (wxRect *) 0 ;
6537 wxPoint *arg2 = 0 ;
6538 void *argp1 = 0 ;
6539 int res1 = 0 ;
6540 wxPoint temp2 ;
6541 PyObject * obj0 = 0 ;
6542 PyObject * obj1 = 0 ;
6543 char * kwnames[] = {
6544 (char *) "self",(char *) "p", NULL
6545 };
6546
6547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6549 if (!SWIG_IsOK(res1)) {
6550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6551 }
6552 arg1 = reinterpret_cast< wxRect * >(argp1);
6553 {
6554 arg2 = &temp2;
6555 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6556 }
6557 {
6558 PyThreadState* __tstate = wxPyBeginAllowThreads();
6559 (arg1)->SetPosition((wxPoint const &)*arg2);
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 resultobj = SWIG_Py_Void();
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6571 PyObject *resultobj = 0;
6572 wxRect *arg1 = (wxRect *) 0 ;
6573 wxSize result;
6574 void *argp1 = 0 ;
6575 int res1 = 0 ;
6576 PyObject *swig_obj[1] ;
6577
6578 if (!args) SWIG_fail;
6579 swig_obj[0] = args;
6580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6581 if (!SWIG_IsOK(res1)) {
6582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6583 }
6584 arg1 = reinterpret_cast< wxRect * >(argp1);
6585 {
6586 PyThreadState* __tstate = wxPyBeginAllowThreads();
6587 result = ((wxRect const *)arg1)->GetSize();
6588 wxPyEndAllowThreads(__tstate);
6589 if (PyErr_Occurred()) SWIG_fail;
6590 }
6591 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6592 return resultobj;
6593 fail:
6594 return NULL;
6595 }
6596
6597
6598 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6599 PyObject *resultobj = 0;
6600 wxRect *arg1 = (wxRect *) 0 ;
6601 wxSize *arg2 = 0 ;
6602 void *argp1 = 0 ;
6603 int res1 = 0 ;
6604 wxSize temp2 ;
6605 PyObject * obj0 = 0 ;
6606 PyObject * obj1 = 0 ;
6607 char * kwnames[] = {
6608 (char *) "self",(char *) "s", NULL
6609 };
6610
6611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6613 if (!SWIG_IsOK(res1)) {
6614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6615 }
6616 arg1 = reinterpret_cast< wxRect * >(argp1);
6617 {
6618 arg2 = &temp2;
6619 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6620 }
6621 {
6622 PyThreadState* __tstate = wxPyBeginAllowThreads();
6623 (arg1)->SetSize((wxSize const &)*arg2);
6624 wxPyEndAllowThreads(__tstate);
6625 if (PyErr_Occurred()) SWIG_fail;
6626 }
6627 resultobj = SWIG_Py_Void();
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6635 PyObject *resultobj = 0;
6636 wxRect *arg1 = (wxRect *) 0 ;
6637 bool result;
6638 void *argp1 = 0 ;
6639 int res1 = 0 ;
6640 PyObject *swig_obj[1] ;
6641
6642 if (!args) SWIG_fail;
6643 swig_obj[0] = args;
6644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6645 if (!SWIG_IsOK(res1)) {
6646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6647 }
6648 arg1 = reinterpret_cast< wxRect * >(argp1);
6649 {
6650 PyThreadState* __tstate = wxPyBeginAllowThreads();
6651 result = (bool)((wxRect const *)arg1)->IsEmpty();
6652 wxPyEndAllowThreads(__tstate);
6653 if (PyErr_Occurred()) SWIG_fail;
6654 }
6655 {
6656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6657 }
6658 return resultobj;
6659 fail:
6660 return NULL;
6661 }
6662
6663
6664 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6665 PyObject *resultobj = 0;
6666 wxRect *arg1 = (wxRect *) 0 ;
6667 wxPoint result;
6668 void *argp1 = 0 ;
6669 int res1 = 0 ;
6670 PyObject *swig_obj[1] ;
6671
6672 if (!args) SWIG_fail;
6673 swig_obj[0] = args;
6674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6675 if (!SWIG_IsOK(res1)) {
6676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6677 }
6678 arg1 = reinterpret_cast< wxRect * >(argp1);
6679 {
6680 PyThreadState* __tstate = wxPyBeginAllowThreads();
6681 result = ((wxRect const *)arg1)->GetTopLeft();
6682 wxPyEndAllowThreads(__tstate);
6683 if (PyErr_Occurred()) SWIG_fail;
6684 }
6685 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6686 return resultobj;
6687 fail:
6688 return NULL;
6689 }
6690
6691
6692 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6693 PyObject *resultobj = 0;
6694 wxRect *arg1 = (wxRect *) 0 ;
6695 wxPoint *arg2 = 0 ;
6696 void *argp1 = 0 ;
6697 int res1 = 0 ;
6698 wxPoint temp2 ;
6699 PyObject * obj0 = 0 ;
6700 PyObject * obj1 = 0 ;
6701 char * kwnames[] = {
6702 (char *) "self",(char *) "p", NULL
6703 };
6704
6705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6707 if (!SWIG_IsOK(res1)) {
6708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6709 }
6710 arg1 = reinterpret_cast< wxRect * >(argp1);
6711 {
6712 arg2 = &temp2;
6713 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6714 }
6715 {
6716 PyThreadState* __tstate = wxPyBeginAllowThreads();
6717 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6718 wxPyEndAllowThreads(__tstate);
6719 if (PyErr_Occurred()) SWIG_fail;
6720 }
6721 resultobj = SWIG_Py_Void();
6722 return resultobj;
6723 fail:
6724 return NULL;
6725 }
6726
6727
6728 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6729 PyObject *resultobj = 0;
6730 wxRect *arg1 = (wxRect *) 0 ;
6731 wxPoint result;
6732 void *argp1 = 0 ;
6733 int res1 = 0 ;
6734 PyObject *swig_obj[1] ;
6735
6736 if (!args) SWIG_fail;
6737 swig_obj[0] = args;
6738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6739 if (!SWIG_IsOK(res1)) {
6740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6741 }
6742 arg1 = reinterpret_cast< wxRect * >(argp1);
6743 {
6744 PyThreadState* __tstate = wxPyBeginAllowThreads();
6745 result = ((wxRect const *)arg1)->GetBottomRight();
6746 wxPyEndAllowThreads(__tstate);
6747 if (PyErr_Occurred()) SWIG_fail;
6748 }
6749 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6750 return resultobj;
6751 fail:
6752 return NULL;
6753 }
6754
6755
6756 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6757 PyObject *resultobj = 0;
6758 wxRect *arg1 = (wxRect *) 0 ;
6759 wxPoint *arg2 = 0 ;
6760 void *argp1 = 0 ;
6761 int res1 = 0 ;
6762 wxPoint temp2 ;
6763 PyObject * obj0 = 0 ;
6764 PyObject * obj1 = 0 ;
6765 char * kwnames[] = {
6766 (char *) "self",(char *) "p", NULL
6767 };
6768
6769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6771 if (!SWIG_IsOK(res1)) {
6772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6773 }
6774 arg1 = reinterpret_cast< wxRect * >(argp1);
6775 {
6776 arg2 = &temp2;
6777 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6778 }
6779 {
6780 PyThreadState* __tstate = wxPyBeginAllowThreads();
6781 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6782 wxPyEndAllowThreads(__tstate);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 resultobj = SWIG_Py_Void();
6786 return resultobj;
6787 fail:
6788 return NULL;
6789 }
6790
6791
6792 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6793 PyObject *resultobj = 0;
6794 wxRect *arg1 = (wxRect *) 0 ;
6795 int result;
6796 void *argp1 = 0 ;
6797 int res1 = 0 ;
6798 PyObject *swig_obj[1] ;
6799
6800 if (!args) SWIG_fail;
6801 swig_obj[0] = args;
6802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6803 if (!SWIG_IsOK(res1)) {
6804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6805 }
6806 arg1 = reinterpret_cast< wxRect * >(argp1);
6807 {
6808 PyThreadState* __tstate = wxPyBeginAllowThreads();
6809 result = (int)((wxRect const *)arg1)->GetLeft();
6810 wxPyEndAllowThreads(__tstate);
6811 if (PyErr_Occurred()) SWIG_fail;
6812 }
6813 resultobj = SWIG_From_int(static_cast< int >(result));
6814 return resultobj;
6815 fail:
6816 return NULL;
6817 }
6818
6819
6820 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6821 PyObject *resultobj = 0;
6822 wxRect *arg1 = (wxRect *) 0 ;
6823 int result;
6824 void *argp1 = 0 ;
6825 int res1 = 0 ;
6826 PyObject *swig_obj[1] ;
6827
6828 if (!args) SWIG_fail;
6829 swig_obj[0] = args;
6830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6831 if (!SWIG_IsOK(res1)) {
6832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6833 }
6834 arg1 = reinterpret_cast< wxRect * >(argp1);
6835 {
6836 PyThreadState* __tstate = wxPyBeginAllowThreads();
6837 result = (int)((wxRect const *)arg1)->GetTop();
6838 wxPyEndAllowThreads(__tstate);
6839 if (PyErr_Occurred()) SWIG_fail;
6840 }
6841 resultobj = SWIG_From_int(static_cast< int >(result));
6842 return resultobj;
6843 fail:
6844 return NULL;
6845 }
6846
6847
6848 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6849 PyObject *resultobj = 0;
6850 wxRect *arg1 = (wxRect *) 0 ;
6851 int result;
6852 void *argp1 = 0 ;
6853 int res1 = 0 ;
6854 PyObject *swig_obj[1] ;
6855
6856 if (!args) SWIG_fail;
6857 swig_obj[0] = args;
6858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6859 if (!SWIG_IsOK(res1)) {
6860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6861 }
6862 arg1 = reinterpret_cast< wxRect * >(argp1);
6863 {
6864 PyThreadState* __tstate = wxPyBeginAllowThreads();
6865 result = (int)((wxRect const *)arg1)->GetBottom();
6866 wxPyEndAllowThreads(__tstate);
6867 if (PyErr_Occurred()) SWIG_fail;
6868 }
6869 resultobj = SWIG_From_int(static_cast< int >(result));
6870 return resultobj;
6871 fail:
6872 return NULL;
6873 }
6874
6875
6876 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6877 PyObject *resultobj = 0;
6878 wxRect *arg1 = (wxRect *) 0 ;
6879 int result;
6880 void *argp1 = 0 ;
6881 int res1 = 0 ;
6882 PyObject *swig_obj[1] ;
6883
6884 if (!args) SWIG_fail;
6885 swig_obj[0] = args;
6886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6887 if (!SWIG_IsOK(res1)) {
6888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6889 }
6890 arg1 = reinterpret_cast< wxRect * >(argp1);
6891 {
6892 PyThreadState* __tstate = wxPyBeginAllowThreads();
6893 result = (int)((wxRect const *)arg1)->GetRight();
6894 wxPyEndAllowThreads(__tstate);
6895 if (PyErr_Occurred()) SWIG_fail;
6896 }
6897 resultobj = SWIG_From_int(static_cast< int >(result));
6898 return resultobj;
6899 fail:
6900 return NULL;
6901 }
6902
6903
6904 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6905 PyObject *resultobj = 0;
6906 wxRect *arg1 = (wxRect *) 0 ;
6907 int arg2 ;
6908 void *argp1 = 0 ;
6909 int res1 = 0 ;
6910 int val2 ;
6911 int ecode2 = 0 ;
6912 PyObject * obj0 = 0 ;
6913 PyObject * obj1 = 0 ;
6914 char * kwnames[] = {
6915 (char *) "self",(char *) "left", NULL
6916 };
6917
6918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6920 if (!SWIG_IsOK(res1)) {
6921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6922 }
6923 arg1 = reinterpret_cast< wxRect * >(argp1);
6924 ecode2 = SWIG_AsVal_int(obj1, &val2);
6925 if (!SWIG_IsOK(ecode2)) {
6926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6927 }
6928 arg2 = static_cast< int >(val2);
6929 {
6930 PyThreadState* __tstate = wxPyBeginAllowThreads();
6931 (arg1)->SetLeft(arg2);
6932 wxPyEndAllowThreads(__tstate);
6933 if (PyErr_Occurred()) SWIG_fail;
6934 }
6935 resultobj = SWIG_Py_Void();
6936 return resultobj;
6937 fail:
6938 return NULL;
6939 }
6940
6941
6942 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6943 PyObject *resultobj = 0;
6944 wxRect *arg1 = (wxRect *) 0 ;
6945 int arg2 ;
6946 void *argp1 = 0 ;
6947 int res1 = 0 ;
6948 int val2 ;
6949 int ecode2 = 0 ;
6950 PyObject * obj0 = 0 ;
6951 PyObject * obj1 = 0 ;
6952 char * kwnames[] = {
6953 (char *) "self",(char *) "right", NULL
6954 };
6955
6956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6958 if (!SWIG_IsOK(res1)) {
6959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6960 }
6961 arg1 = reinterpret_cast< wxRect * >(argp1);
6962 ecode2 = SWIG_AsVal_int(obj1, &val2);
6963 if (!SWIG_IsOK(ecode2)) {
6964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6965 }
6966 arg2 = static_cast< int >(val2);
6967 {
6968 PyThreadState* __tstate = wxPyBeginAllowThreads();
6969 (arg1)->SetRight(arg2);
6970 wxPyEndAllowThreads(__tstate);
6971 if (PyErr_Occurred()) SWIG_fail;
6972 }
6973 resultobj = SWIG_Py_Void();
6974 return resultobj;
6975 fail:
6976 return NULL;
6977 }
6978
6979
6980 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6981 PyObject *resultobj = 0;
6982 wxRect *arg1 = (wxRect *) 0 ;
6983 int arg2 ;
6984 void *argp1 = 0 ;
6985 int res1 = 0 ;
6986 int val2 ;
6987 int ecode2 = 0 ;
6988 PyObject * obj0 = 0 ;
6989 PyObject * obj1 = 0 ;
6990 char * kwnames[] = {
6991 (char *) "self",(char *) "top", NULL
6992 };
6993
6994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6996 if (!SWIG_IsOK(res1)) {
6997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6998 }
6999 arg1 = reinterpret_cast< wxRect * >(argp1);
7000 ecode2 = SWIG_AsVal_int(obj1, &val2);
7001 if (!SWIG_IsOK(ecode2)) {
7002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7003 }
7004 arg2 = static_cast< int >(val2);
7005 {
7006 PyThreadState* __tstate = wxPyBeginAllowThreads();
7007 (arg1)->SetTop(arg2);
7008 wxPyEndAllowThreads(__tstate);
7009 if (PyErr_Occurred()) SWIG_fail;
7010 }
7011 resultobj = SWIG_Py_Void();
7012 return resultobj;
7013 fail:
7014 return NULL;
7015 }
7016
7017
7018 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7019 PyObject *resultobj = 0;
7020 wxRect *arg1 = (wxRect *) 0 ;
7021 int arg2 ;
7022 void *argp1 = 0 ;
7023 int res1 = 0 ;
7024 int val2 ;
7025 int ecode2 = 0 ;
7026 PyObject * obj0 = 0 ;
7027 PyObject * obj1 = 0 ;
7028 char * kwnames[] = {
7029 (char *) "self",(char *) "bottom", NULL
7030 };
7031
7032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7034 if (!SWIG_IsOK(res1)) {
7035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7036 }
7037 arg1 = reinterpret_cast< wxRect * >(argp1);
7038 ecode2 = SWIG_AsVal_int(obj1, &val2);
7039 if (!SWIG_IsOK(ecode2)) {
7040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7041 }
7042 arg2 = static_cast< int >(val2);
7043 {
7044 PyThreadState* __tstate = wxPyBeginAllowThreads();
7045 (arg1)->SetBottom(arg2);
7046 wxPyEndAllowThreads(__tstate);
7047 if (PyErr_Occurred()) SWIG_fail;
7048 }
7049 resultobj = SWIG_Py_Void();
7050 return resultobj;
7051 fail:
7052 return NULL;
7053 }
7054
7055
7056 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7057 PyObject *resultobj = 0;
7058 wxRect *arg1 = (wxRect *) 0 ;
7059 int arg2 ;
7060 int arg3 ;
7061 wxRect *result = 0 ;
7062 void *argp1 = 0 ;
7063 int res1 = 0 ;
7064 int val2 ;
7065 int ecode2 = 0 ;
7066 int val3 ;
7067 int ecode3 = 0 ;
7068 PyObject * obj0 = 0 ;
7069 PyObject * obj1 = 0 ;
7070 PyObject * obj2 = 0 ;
7071 char * kwnames[] = {
7072 (char *) "self",(char *) "dx",(char *) "dy", NULL
7073 };
7074
7075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7077 if (!SWIG_IsOK(res1)) {
7078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7079 }
7080 arg1 = reinterpret_cast< wxRect * >(argp1);
7081 ecode2 = SWIG_AsVal_int(obj1, &val2);
7082 if (!SWIG_IsOK(ecode2)) {
7083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7084 }
7085 arg2 = static_cast< int >(val2);
7086 ecode3 = SWIG_AsVal_int(obj2, &val3);
7087 if (!SWIG_IsOK(ecode3)) {
7088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7089 }
7090 arg3 = static_cast< int >(val3);
7091 {
7092 PyThreadState* __tstate = wxPyBeginAllowThreads();
7093 {
7094 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7095 result = (wxRect *) &_result_ref;
7096 }
7097 wxPyEndAllowThreads(__tstate);
7098 if (PyErr_Occurred()) SWIG_fail;
7099 }
7100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7101 return resultobj;
7102 fail:
7103 return NULL;
7104 }
7105
7106
7107 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7108 PyObject *resultobj = 0;
7109 wxRect *arg1 = (wxRect *) 0 ;
7110 int arg2 ;
7111 int arg3 ;
7112 wxRect *result = 0 ;
7113 void *argp1 = 0 ;
7114 int res1 = 0 ;
7115 int val2 ;
7116 int ecode2 = 0 ;
7117 int val3 ;
7118 int ecode3 = 0 ;
7119 PyObject * obj0 = 0 ;
7120 PyObject * obj1 = 0 ;
7121 PyObject * obj2 = 0 ;
7122 char * kwnames[] = {
7123 (char *) "self",(char *) "dx",(char *) "dy", NULL
7124 };
7125
7126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7128 if (!SWIG_IsOK(res1)) {
7129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7130 }
7131 arg1 = reinterpret_cast< wxRect * >(argp1);
7132 ecode2 = SWIG_AsVal_int(obj1, &val2);
7133 if (!SWIG_IsOK(ecode2)) {
7134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7135 }
7136 arg2 = static_cast< int >(val2);
7137 ecode3 = SWIG_AsVal_int(obj2, &val3);
7138 if (!SWIG_IsOK(ecode3)) {
7139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7140 }
7141 arg3 = static_cast< int >(val3);
7142 {
7143 PyThreadState* __tstate = wxPyBeginAllowThreads();
7144 {
7145 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7146 result = (wxRect *) &_result_ref;
7147 }
7148 wxPyEndAllowThreads(__tstate);
7149 if (PyErr_Occurred()) SWIG_fail;
7150 }
7151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7152 return resultobj;
7153 fail:
7154 return NULL;
7155 }
7156
7157
7158 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7159 PyObject *resultobj = 0;
7160 wxRect *arg1 = (wxRect *) 0 ;
7161 int arg2 ;
7162 int arg3 ;
7163 void *argp1 = 0 ;
7164 int res1 = 0 ;
7165 int val2 ;
7166 int ecode2 = 0 ;
7167 int val3 ;
7168 int ecode3 = 0 ;
7169 PyObject * obj0 = 0 ;
7170 PyObject * obj1 = 0 ;
7171 PyObject * obj2 = 0 ;
7172 char * kwnames[] = {
7173 (char *) "self",(char *) "dx",(char *) "dy", NULL
7174 };
7175
7176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7178 if (!SWIG_IsOK(res1)) {
7179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7180 }
7181 arg1 = reinterpret_cast< wxRect * >(argp1);
7182 ecode2 = SWIG_AsVal_int(obj1, &val2);
7183 if (!SWIG_IsOK(ecode2)) {
7184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7185 }
7186 arg2 = static_cast< int >(val2);
7187 ecode3 = SWIG_AsVal_int(obj2, &val3);
7188 if (!SWIG_IsOK(ecode3)) {
7189 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7190 }
7191 arg3 = static_cast< int >(val3);
7192 {
7193 PyThreadState* __tstate = wxPyBeginAllowThreads();
7194 (arg1)->Offset(arg2,arg3);
7195 wxPyEndAllowThreads(__tstate);
7196 if (PyErr_Occurred()) SWIG_fail;
7197 }
7198 resultobj = SWIG_Py_Void();
7199 return resultobj;
7200 fail:
7201 return NULL;
7202 }
7203
7204
7205 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7206 PyObject *resultobj = 0;
7207 wxRect *arg1 = (wxRect *) 0 ;
7208 wxPoint *arg2 = 0 ;
7209 void *argp1 = 0 ;
7210 int res1 = 0 ;
7211 wxPoint temp2 ;
7212 PyObject * obj0 = 0 ;
7213 PyObject * obj1 = 0 ;
7214 char * kwnames[] = {
7215 (char *) "self",(char *) "pt", NULL
7216 };
7217
7218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7220 if (!SWIG_IsOK(res1)) {
7221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7222 }
7223 arg1 = reinterpret_cast< wxRect * >(argp1);
7224 {
7225 arg2 = &temp2;
7226 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7227 }
7228 {
7229 PyThreadState* __tstate = wxPyBeginAllowThreads();
7230 (arg1)->Offset((wxPoint const &)*arg2);
7231 wxPyEndAllowThreads(__tstate);
7232 if (PyErr_Occurred()) SWIG_fail;
7233 }
7234 resultobj = SWIG_Py_Void();
7235 return resultobj;
7236 fail:
7237 return NULL;
7238 }
7239
7240
7241 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7242 PyObject *resultobj = 0;
7243 wxRect *arg1 = (wxRect *) 0 ;
7244 wxRect *arg2 = 0 ;
7245 wxRect result;
7246 void *argp1 = 0 ;
7247 int res1 = 0 ;
7248 wxRect temp2 ;
7249 PyObject * obj0 = 0 ;
7250 PyObject * obj1 = 0 ;
7251 char * kwnames[] = {
7252 (char *) "self",(char *) "rect", NULL
7253 };
7254
7255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7257 if (!SWIG_IsOK(res1)) {
7258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7259 }
7260 arg1 = reinterpret_cast< wxRect * >(argp1);
7261 {
7262 arg2 = &temp2;
7263 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7264 }
7265 {
7266 PyThreadState* __tstate = wxPyBeginAllowThreads();
7267 result = (arg1)->Intersect((wxRect const &)*arg2);
7268 wxPyEndAllowThreads(__tstate);
7269 if (PyErr_Occurred()) SWIG_fail;
7270 }
7271 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7272 return resultobj;
7273 fail:
7274 return NULL;
7275 }
7276
7277
7278 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7279 PyObject *resultobj = 0;
7280 wxRect *arg1 = (wxRect *) 0 ;
7281 wxRect *arg2 = 0 ;
7282 wxRect result;
7283 void *argp1 = 0 ;
7284 int res1 = 0 ;
7285 wxRect temp2 ;
7286 PyObject * obj0 = 0 ;
7287 PyObject * obj1 = 0 ;
7288 char * kwnames[] = {
7289 (char *) "self",(char *) "rect", NULL
7290 };
7291
7292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7294 if (!SWIG_IsOK(res1)) {
7295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7296 }
7297 arg1 = reinterpret_cast< wxRect * >(argp1);
7298 {
7299 arg2 = &temp2;
7300 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7301 }
7302 {
7303 PyThreadState* __tstate = wxPyBeginAllowThreads();
7304 result = (arg1)->Union((wxRect const &)*arg2);
7305 wxPyEndAllowThreads(__tstate);
7306 if (PyErr_Occurred()) SWIG_fail;
7307 }
7308 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7309 return resultobj;
7310 fail:
7311 return NULL;
7312 }
7313
7314
7315 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7316 PyObject *resultobj = 0;
7317 wxRect *arg1 = (wxRect *) 0 ;
7318 wxRect *arg2 = 0 ;
7319 wxRect result;
7320 void *argp1 = 0 ;
7321 int res1 = 0 ;
7322 wxRect temp2 ;
7323 PyObject * obj0 = 0 ;
7324 PyObject * obj1 = 0 ;
7325 char * kwnames[] = {
7326 (char *) "self",(char *) "rect", NULL
7327 };
7328
7329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7331 if (!SWIG_IsOK(res1)) {
7332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7333 }
7334 arg1 = reinterpret_cast< wxRect * >(argp1);
7335 {
7336 arg2 = &temp2;
7337 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7338 }
7339 {
7340 PyThreadState* __tstate = wxPyBeginAllowThreads();
7341 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7342 wxPyEndAllowThreads(__tstate);
7343 if (PyErr_Occurred()) SWIG_fail;
7344 }
7345 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7346 return resultobj;
7347 fail:
7348 return NULL;
7349 }
7350
7351
7352 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7353 PyObject *resultobj = 0;
7354 wxRect *arg1 = (wxRect *) 0 ;
7355 wxRect *arg2 = 0 ;
7356 wxRect *result = 0 ;
7357 void *argp1 = 0 ;
7358 int res1 = 0 ;
7359 wxRect temp2 ;
7360 PyObject * obj0 = 0 ;
7361 PyObject * obj1 = 0 ;
7362 char * kwnames[] = {
7363 (char *) "self",(char *) "rect", NULL
7364 };
7365
7366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7368 if (!SWIG_IsOK(res1)) {
7369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7370 }
7371 arg1 = reinterpret_cast< wxRect * >(argp1);
7372 {
7373 arg2 = &temp2;
7374 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7375 }
7376 {
7377 PyThreadState* __tstate = wxPyBeginAllowThreads();
7378 {
7379 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7380 result = (wxRect *) &_result_ref;
7381 }
7382 wxPyEndAllowThreads(__tstate);
7383 if (PyErr_Occurred()) SWIG_fail;
7384 }
7385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7386 return resultobj;
7387 fail:
7388 return NULL;
7389 }
7390
7391
7392 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7393 PyObject *resultobj = 0;
7394 wxRect *arg1 = (wxRect *) 0 ;
7395 PyObject *arg2 = (PyObject *) 0 ;
7396 bool result;
7397 void *argp1 = 0 ;
7398 int res1 = 0 ;
7399 PyObject * obj0 = 0 ;
7400 PyObject * obj1 = 0 ;
7401 char * kwnames[] = {
7402 (char *) "self",(char *) "other", NULL
7403 };
7404
7405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7407 if (!SWIG_IsOK(res1)) {
7408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7409 }
7410 arg1 = reinterpret_cast< wxRect * >(argp1);
7411 arg2 = obj1;
7412 {
7413 result = (bool)wxRect___eq__(arg1,arg2);
7414 if (PyErr_Occurred()) SWIG_fail;
7415 }
7416 {
7417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7418 }
7419 return resultobj;
7420 fail:
7421 return NULL;
7422 }
7423
7424
7425 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7426 PyObject *resultobj = 0;
7427 wxRect *arg1 = (wxRect *) 0 ;
7428 PyObject *arg2 = (PyObject *) 0 ;
7429 bool result;
7430 void *argp1 = 0 ;
7431 int res1 = 0 ;
7432 PyObject * obj0 = 0 ;
7433 PyObject * obj1 = 0 ;
7434 char * kwnames[] = {
7435 (char *) "self",(char *) "other", NULL
7436 };
7437
7438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7440 if (!SWIG_IsOK(res1)) {
7441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7442 }
7443 arg1 = reinterpret_cast< wxRect * >(argp1);
7444 arg2 = obj1;
7445 {
7446 result = (bool)wxRect___ne__(arg1,arg2);
7447 if (PyErr_Occurred()) SWIG_fail;
7448 }
7449 {
7450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7451 }
7452 return resultobj;
7453 fail:
7454 return NULL;
7455 }
7456
7457
7458 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7459 PyObject *resultobj = 0;
7460 wxRect *arg1 = (wxRect *) 0 ;
7461 int arg2 ;
7462 int arg3 ;
7463 bool result;
7464 void *argp1 = 0 ;
7465 int res1 = 0 ;
7466 int val2 ;
7467 int ecode2 = 0 ;
7468 int val3 ;
7469 int ecode3 = 0 ;
7470 PyObject * obj0 = 0 ;
7471 PyObject * obj1 = 0 ;
7472 PyObject * obj2 = 0 ;
7473 char * kwnames[] = {
7474 (char *) "self",(char *) "x",(char *) "y", NULL
7475 };
7476
7477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7479 if (!SWIG_IsOK(res1)) {
7480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7481 }
7482 arg1 = reinterpret_cast< wxRect * >(argp1);
7483 ecode2 = SWIG_AsVal_int(obj1, &val2);
7484 if (!SWIG_IsOK(ecode2)) {
7485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7486 }
7487 arg2 = static_cast< int >(val2);
7488 ecode3 = SWIG_AsVal_int(obj2, &val3);
7489 if (!SWIG_IsOK(ecode3)) {
7490 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7491 }
7492 arg3 = static_cast< int >(val3);
7493 {
7494 PyThreadState* __tstate = wxPyBeginAllowThreads();
7495 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7496 wxPyEndAllowThreads(__tstate);
7497 if (PyErr_Occurred()) SWIG_fail;
7498 }
7499 {
7500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7501 }
7502 return resultobj;
7503 fail:
7504 return NULL;
7505 }
7506
7507
7508 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7509 PyObject *resultobj = 0;
7510 wxRect *arg1 = (wxRect *) 0 ;
7511 wxPoint *arg2 = 0 ;
7512 bool result;
7513 void *argp1 = 0 ;
7514 int res1 = 0 ;
7515 wxPoint temp2 ;
7516 PyObject * obj0 = 0 ;
7517 PyObject * obj1 = 0 ;
7518 char * kwnames[] = {
7519 (char *) "self",(char *) "pt", NULL
7520 };
7521
7522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7524 if (!SWIG_IsOK(res1)) {
7525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7526 }
7527 arg1 = reinterpret_cast< wxRect * >(argp1);
7528 {
7529 arg2 = &temp2;
7530 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7531 }
7532 {
7533 PyThreadState* __tstate = wxPyBeginAllowThreads();
7534 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7535 wxPyEndAllowThreads(__tstate);
7536 if (PyErr_Occurred()) SWIG_fail;
7537 }
7538 {
7539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7540 }
7541 return resultobj;
7542 fail:
7543 return NULL;
7544 }
7545
7546
7547 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7548 PyObject *resultobj = 0;
7549 wxRect *arg1 = (wxRect *) 0 ;
7550 wxRect *arg2 = 0 ;
7551 bool result;
7552 void *argp1 = 0 ;
7553 int res1 = 0 ;
7554 wxRect temp2 ;
7555 PyObject * obj0 = 0 ;
7556 PyObject * obj1 = 0 ;
7557 char * kwnames[] = {
7558 (char *) "self",(char *) "rect", NULL
7559 };
7560
7561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7563 if (!SWIG_IsOK(res1)) {
7564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7565 }
7566 arg1 = reinterpret_cast< wxRect * >(argp1);
7567 {
7568 arg2 = &temp2;
7569 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7570 }
7571 {
7572 PyThreadState* __tstate = wxPyBeginAllowThreads();
7573 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7574 wxPyEndAllowThreads(__tstate);
7575 if (PyErr_Occurred()) SWIG_fail;
7576 }
7577 {
7578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7579 }
7580 return resultobj;
7581 fail:
7582 return NULL;
7583 }
7584
7585
7586 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7587 PyObject *resultobj = 0;
7588 wxRect *arg1 = (wxRect *) 0 ;
7589 wxRect *arg2 = 0 ;
7590 int arg3 = (int) wxBOTH ;
7591 wxRect result;
7592 void *argp1 = 0 ;
7593 int res1 = 0 ;
7594 wxRect temp2 ;
7595 int val3 ;
7596 int ecode3 = 0 ;
7597 PyObject * obj0 = 0 ;
7598 PyObject * obj1 = 0 ;
7599 PyObject * obj2 = 0 ;
7600 char * kwnames[] = {
7601 (char *) "self",(char *) "r",(char *) "dir", NULL
7602 };
7603
7604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7606 if (!SWIG_IsOK(res1)) {
7607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7608 }
7609 arg1 = reinterpret_cast< wxRect * >(argp1);
7610 {
7611 arg2 = &temp2;
7612 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7613 }
7614 if (obj2) {
7615 ecode3 = SWIG_AsVal_int(obj2, &val3);
7616 if (!SWIG_IsOK(ecode3)) {
7617 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7618 }
7619 arg3 = static_cast< int >(val3);
7620 }
7621 {
7622 PyThreadState* __tstate = wxPyBeginAllowThreads();
7623 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7624 wxPyEndAllowThreads(__tstate);
7625 if (PyErr_Occurred()) SWIG_fail;
7626 }
7627 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7628 return resultobj;
7629 fail:
7630 return NULL;
7631 }
7632
7633
7634 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7635 PyObject *resultobj = 0;
7636 wxRect *arg1 = (wxRect *) 0 ;
7637 int arg2 ;
7638 void *argp1 = 0 ;
7639 int res1 = 0 ;
7640 int val2 ;
7641 int ecode2 = 0 ;
7642 PyObject *swig_obj[2] ;
7643
7644 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7646 if (!SWIG_IsOK(res1)) {
7647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7648 }
7649 arg1 = reinterpret_cast< wxRect * >(argp1);
7650 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7651 if (!SWIG_IsOK(ecode2)) {
7652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7653 }
7654 arg2 = static_cast< int >(val2);
7655 if (arg1) (arg1)->x = arg2;
7656
7657 resultobj = SWIG_Py_Void();
7658 return resultobj;
7659 fail:
7660 return NULL;
7661 }
7662
7663
7664 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7665 PyObject *resultobj = 0;
7666 wxRect *arg1 = (wxRect *) 0 ;
7667 int result;
7668 void *argp1 = 0 ;
7669 int res1 = 0 ;
7670 PyObject *swig_obj[1] ;
7671
7672 if (!args) SWIG_fail;
7673 swig_obj[0] = args;
7674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7675 if (!SWIG_IsOK(res1)) {
7676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7677 }
7678 arg1 = reinterpret_cast< wxRect * >(argp1);
7679 result = (int) ((arg1)->x);
7680 resultobj = SWIG_From_int(static_cast< int >(result));
7681 return resultobj;
7682 fail:
7683 return NULL;
7684 }
7685
7686
7687 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7688 PyObject *resultobj = 0;
7689 wxRect *arg1 = (wxRect *) 0 ;
7690 int arg2 ;
7691 void *argp1 = 0 ;
7692 int res1 = 0 ;
7693 int val2 ;
7694 int ecode2 = 0 ;
7695 PyObject *swig_obj[2] ;
7696
7697 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7699 if (!SWIG_IsOK(res1)) {
7700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7701 }
7702 arg1 = reinterpret_cast< wxRect * >(argp1);
7703 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7704 if (!SWIG_IsOK(ecode2)) {
7705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7706 }
7707 arg2 = static_cast< int >(val2);
7708 if (arg1) (arg1)->y = arg2;
7709
7710 resultobj = SWIG_Py_Void();
7711 return resultobj;
7712 fail:
7713 return NULL;
7714 }
7715
7716
7717 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7718 PyObject *resultobj = 0;
7719 wxRect *arg1 = (wxRect *) 0 ;
7720 int result;
7721 void *argp1 = 0 ;
7722 int res1 = 0 ;
7723 PyObject *swig_obj[1] ;
7724
7725 if (!args) SWIG_fail;
7726 swig_obj[0] = args;
7727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7728 if (!SWIG_IsOK(res1)) {
7729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7730 }
7731 arg1 = reinterpret_cast< wxRect * >(argp1);
7732 result = (int) ((arg1)->y);
7733 resultobj = SWIG_From_int(static_cast< int >(result));
7734 return resultobj;
7735 fail:
7736 return NULL;
7737 }
7738
7739
7740 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7741 PyObject *resultobj = 0;
7742 wxRect *arg1 = (wxRect *) 0 ;
7743 int arg2 ;
7744 void *argp1 = 0 ;
7745 int res1 = 0 ;
7746 int val2 ;
7747 int ecode2 = 0 ;
7748 PyObject *swig_obj[2] ;
7749
7750 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7752 if (!SWIG_IsOK(res1)) {
7753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7754 }
7755 arg1 = reinterpret_cast< wxRect * >(argp1);
7756 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7757 if (!SWIG_IsOK(ecode2)) {
7758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7759 }
7760 arg2 = static_cast< int >(val2);
7761 if (arg1) (arg1)->width = arg2;
7762
7763 resultobj = SWIG_Py_Void();
7764 return resultobj;
7765 fail:
7766 return NULL;
7767 }
7768
7769
7770 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7771 PyObject *resultobj = 0;
7772 wxRect *arg1 = (wxRect *) 0 ;
7773 int result;
7774 void *argp1 = 0 ;
7775 int res1 = 0 ;
7776 PyObject *swig_obj[1] ;
7777
7778 if (!args) SWIG_fail;
7779 swig_obj[0] = args;
7780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7781 if (!SWIG_IsOK(res1)) {
7782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7783 }
7784 arg1 = reinterpret_cast< wxRect * >(argp1);
7785 result = (int) ((arg1)->width);
7786 resultobj = SWIG_From_int(static_cast< int >(result));
7787 return resultobj;
7788 fail:
7789 return NULL;
7790 }
7791
7792
7793 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7794 PyObject *resultobj = 0;
7795 wxRect *arg1 = (wxRect *) 0 ;
7796 int arg2 ;
7797 void *argp1 = 0 ;
7798 int res1 = 0 ;
7799 int val2 ;
7800 int ecode2 = 0 ;
7801 PyObject *swig_obj[2] ;
7802
7803 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7805 if (!SWIG_IsOK(res1)) {
7806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7807 }
7808 arg1 = reinterpret_cast< wxRect * >(argp1);
7809 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7810 if (!SWIG_IsOK(ecode2)) {
7811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7812 }
7813 arg2 = static_cast< int >(val2);
7814 if (arg1) (arg1)->height = arg2;
7815
7816 resultobj = SWIG_Py_Void();
7817 return resultobj;
7818 fail:
7819 return NULL;
7820 }
7821
7822
7823 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7824 PyObject *resultobj = 0;
7825 wxRect *arg1 = (wxRect *) 0 ;
7826 int result;
7827 void *argp1 = 0 ;
7828 int res1 = 0 ;
7829 PyObject *swig_obj[1] ;
7830
7831 if (!args) SWIG_fail;
7832 swig_obj[0] = args;
7833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7834 if (!SWIG_IsOK(res1)) {
7835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7836 }
7837 arg1 = reinterpret_cast< wxRect * >(argp1);
7838 result = (int) ((arg1)->height);
7839 resultobj = SWIG_From_int(static_cast< int >(result));
7840 return resultobj;
7841 fail:
7842 return NULL;
7843 }
7844
7845
7846 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7847 PyObject *resultobj = 0;
7848 wxRect *arg1 = (wxRect *) 0 ;
7849 int arg2 = (int) 0 ;
7850 int arg3 = (int) 0 ;
7851 int arg4 = (int) 0 ;
7852 int arg5 = (int) 0 ;
7853 void *argp1 = 0 ;
7854 int res1 = 0 ;
7855 int val2 ;
7856 int ecode2 = 0 ;
7857 int val3 ;
7858 int ecode3 = 0 ;
7859 int val4 ;
7860 int ecode4 = 0 ;
7861 int val5 ;
7862 int ecode5 = 0 ;
7863 PyObject * obj0 = 0 ;
7864 PyObject * obj1 = 0 ;
7865 PyObject * obj2 = 0 ;
7866 PyObject * obj3 = 0 ;
7867 PyObject * obj4 = 0 ;
7868 char * kwnames[] = {
7869 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7870 };
7871
7872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7874 if (!SWIG_IsOK(res1)) {
7875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7876 }
7877 arg1 = reinterpret_cast< wxRect * >(argp1);
7878 if (obj1) {
7879 ecode2 = SWIG_AsVal_int(obj1, &val2);
7880 if (!SWIG_IsOK(ecode2)) {
7881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7882 }
7883 arg2 = static_cast< int >(val2);
7884 }
7885 if (obj2) {
7886 ecode3 = SWIG_AsVal_int(obj2, &val3);
7887 if (!SWIG_IsOK(ecode3)) {
7888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7889 }
7890 arg3 = static_cast< int >(val3);
7891 }
7892 if (obj3) {
7893 ecode4 = SWIG_AsVal_int(obj3, &val4);
7894 if (!SWIG_IsOK(ecode4)) {
7895 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7896 }
7897 arg4 = static_cast< int >(val4);
7898 }
7899 if (obj4) {
7900 ecode5 = SWIG_AsVal_int(obj4, &val5);
7901 if (!SWIG_IsOK(ecode5)) {
7902 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7903 }
7904 arg5 = static_cast< int >(val5);
7905 }
7906 {
7907 PyThreadState* __tstate = wxPyBeginAllowThreads();
7908 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7909 wxPyEndAllowThreads(__tstate);
7910 if (PyErr_Occurred()) SWIG_fail;
7911 }
7912 resultobj = SWIG_Py_Void();
7913 return resultobj;
7914 fail:
7915 return NULL;
7916 }
7917
7918
7919 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7920 PyObject *resultobj = 0;
7921 wxRect *arg1 = (wxRect *) 0 ;
7922 PyObject *result = 0 ;
7923 void *argp1 = 0 ;
7924 int res1 = 0 ;
7925 PyObject *swig_obj[1] ;
7926
7927 if (!args) SWIG_fail;
7928 swig_obj[0] = args;
7929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7930 if (!SWIG_IsOK(res1)) {
7931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7932 }
7933 arg1 = reinterpret_cast< wxRect * >(argp1);
7934 {
7935 PyThreadState* __tstate = wxPyBeginAllowThreads();
7936 result = (PyObject *)wxRect_Get(arg1);
7937 wxPyEndAllowThreads(__tstate);
7938 if (PyErr_Occurred()) SWIG_fail;
7939 }
7940 resultobj = result;
7941 return resultobj;
7942 fail:
7943 return NULL;
7944 }
7945
7946
7947 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7948 PyObject *obj;
7949 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7950 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7951 return SWIG_Py_Void();
7952 }
7953
7954 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7955 return SWIG_Python_InitShadowInstance(args);
7956 }
7957
7958 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7959 PyObject *resultobj = 0;
7960 wxRect *arg1 = (wxRect *) 0 ;
7961 wxRect *arg2 = (wxRect *) 0 ;
7962 PyObject *result = 0 ;
7963 void *argp1 = 0 ;
7964 int res1 = 0 ;
7965 void *argp2 = 0 ;
7966 int res2 = 0 ;
7967 PyObject * obj0 = 0 ;
7968 PyObject * obj1 = 0 ;
7969 char * kwnames[] = {
7970 (char *) "r1",(char *) "r2", NULL
7971 };
7972
7973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7975 if (!SWIG_IsOK(res1)) {
7976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7977 }
7978 arg1 = reinterpret_cast< wxRect * >(argp1);
7979 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7980 if (!SWIG_IsOK(res2)) {
7981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7982 }
7983 arg2 = reinterpret_cast< wxRect * >(argp2);
7984 {
7985 if (!wxPyCheckForApp()) SWIG_fail;
7986 PyThreadState* __tstate = wxPyBeginAllowThreads();
7987 result = (PyObject *)wxIntersectRect(arg1,arg2);
7988 wxPyEndAllowThreads(__tstate);
7989 if (PyErr_Occurred()) SWIG_fail;
7990 }
7991 resultobj = result;
7992 return resultobj;
7993 fail:
7994 return NULL;
7995 }
7996
7997
7998 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7999 PyObject *resultobj = 0;
8000 double arg1 = (double) 0.0 ;
8001 double arg2 = (double) 0.0 ;
8002 wxPoint2D *result = 0 ;
8003 double val1 ;
8004 int ecode1 = 0 ;
8005 double val2 ;
8006 int ecode2 = 0 ;
8007 PyObject * obj0 = 0 ;
8008 PyObject * obj1 = 0 ;
8009 char * kwnames[] = {
8010 (char *) "x",(char *) "y", NULL
8011 };
8012
8013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8014 if (obj0) {
8015 ecode1 = SWIG_AsVal_double(obj0, &val1);
8016 if (!SWIG_IsOK(ecode1)) {
8017 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8018 }
8019 arg1 = static_cast< double >(val1);
8020 }
8021 if (obj1) {
8022 ecode2 = SWIG_AsVal_double(obj1, &val2);
8023 if (!SWIG_IsOK(ecode2)) {
8024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8025 }
8026 arg2 = static_cast< double >(val2);
8027 }
8028 {
8029 PyThreadState* __tstate = wxPyBeginAllowThreads();
8030 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8031 wxPyEndAllowThreads(__tstate);
8032 if (PyErr_Occurred()) SWIG_fail;
8033 }
8034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8035 return resultobj;
8036 fail:
8037 return NULL;
8038 }
8039
8040
8041 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8042 PyObject *resultobj = 0;
8043 wxPoint2D *arg1 = 0 ;
8044 wxPoint2D *result = 0 ;
8045 wxPoint2D temp1 ;
8046 PyObject * obj0 = 0 ;
8047 char * kwnames[] = {
8048 (char *) "pt", NULL
8049 };
8050
8051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8052 {
8053 arg1 = &temp1;
8054 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8055 }
8056 {
8057 PyThreadState* __tstate = wxPyBeginAllowThreads();
8058 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8059 wxPyEndAllowThreads(__tstate);
8060 if (PyErr_Occurred()) SWIG_fail;
8061 }
8062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8063 return resultobj;
8064 fail:
8065 return NULL;
8066 }
8067
8068
8069 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8070 PyObject *resultobj = 0;
8071 wxPoint *arg1 = 0 ;
8072 wxPoint2D *result = 0 ;
8073 wxPoint temp1 ;
8074 PyObject * obj0 = 0 ;
8075 char * kwnames[] = {
8076 (char *) "pt", NULL
8077 };
8078
8079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8080 {
8081 arg1 = &temp1;
8082 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8083 }
8084 {
8085 PyThreadState* __tstate = wxPyBeginAllowThreads();
8086 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8087 wxPyEndAllowThreads(__tstate);
8088 if (PyErr_Occurred()) SWIG_fail;
8089 }
8090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8091 return resultobj;
8092 fail:
8093 return NULL;
8094 }
8095
8096
8097 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8098 PyObject *resultobj = 0;
8099 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8100 int *arg2 = (int *) 0 ;
8101 int *arg3 = (int *) 0 ;
8102 void *argp1 = 0 ;
8103 int res1 = 0 ;
8104 int temp2 ;
8105 int res2 = SWIG_TMPOBJ ;
8106 int temp3 ;
8107 int res3 = SWIG_TMPOBJ ;
8108 PyObject *swig_obj[1] ;
8109
8110 arg2 = &temp2;
8111 arg3 = &temp3;
8112 if (!args) SWIG_fail;
8113 swig_obj[0] = args;
8114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8115 if (!SWIG_IsOK(res1)) {
8116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8117 }
8118 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8119 {
8120 PyThreadState* __tstate = wxPyBeginAllowThreads();
8121 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8122 wxPyEndAllowThreads(__tstate);
8123 if (PyErr_Occurred()) SWIG_fail;
8124 }
8125 resultobj = SWIG_Py_Void();
8126 if (SWIG_IsTmpObj(res2)) {
8127 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8128 } else {
8129 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8130 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8131 }
8132 if (SWIG_IsTmpObj(res3)) {
8133 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8134 } else {
8135 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8137 }
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8145 PyObject *resultobj = 0;
8146 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8147 int *arg2 = (int *) 0 ;
8148 int *arg3 = (int *) 0 ;
8149 void *argp1 = 0 ;
8150 int res1 = 0 ;
8151 int temp2 ;
8152 int res2 = SWIG_TMPOBJ ;
8153 int temp3 ;
8154 int res3 = SWIG_TMPOBJ ;
8155 PyObject *swig_obj[1] ;
8156
8157 arg2 = &temp2;
8158 arg3 = &temp3;
8159 if (!args) SWIG_fail;
8160 swig_obj[0] = args;
8161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8162 if (!SWIG_IsOK(res1)) {
8163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8164 }
8165 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8166 {
8167 PyThreadState* __tstate = wxPyBeginAllowThreads();
8168 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8169 wxPyEndAllowThreads(__tstate);
8170 if (PyErr_Occurred()) SWIG_fail;
8171 }
8172 resultobj = SWIG_Py_Void();
8173 if (SWIG_IsTmpObj(res2)) {
8174 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8175 } else {
8176 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8177 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8178 }
8179 if (SWIG_IsTmpObj(res3)) {
8180 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8181 } else {
8182 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8183 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8184 }
8185 return resultobj;
8186 fail:
8187 return NULL;
8188 }
8189
8190
8191 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8192 PyObject *resultobj = 0;
8193 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8194 double result;
8195 void *argp1 = 0 ;
8196 int res1 = 0 ;
8197 PyObject *swig_obj[1] ;
8198
8199 if (!args) SWIG_fail;
8200 swig_obj[0] = args;
8201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8202 if (!SWIG_IsOK(res1)) {
8203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8204 }
8205 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8206 {
8207 PyThreadState* __tstate = wxPyBeginAllowThreads();
8208 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8209 wxPyEndAllowThreads(__tstate);
8210 if (PyErr_Occurred()) SWIG_fail;
8211 }
8212 resultobj = SWIG_From_double(static_cast< double >(result));
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8220 PyObject *resultobj = 0;
8221 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8222 double result;
8223 void *argp1 = 0 ;
8224 int res1 = 0 ;
8225 PyObject *swig_obj[1] ;
8226
8227 if (!args) SWIG_fail;
8228 swig_obj[0] = args;
8229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8230 if (!SWIG_IsOK(res1)) {
8231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8232 }
8233 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8234 {
8235 PyThreadState* __tstate = wxPyBeginAllowThreads();
8236 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8237 wxPyEndAllowThreads(__tstate);
8238 if (PyErr_Occurred()) SWIG_fail;
8239 }
8240 resultobj = SWIG_From_double(static_cast< double >(result));
8241 return resultobj;
8242 fail:
8243 return NULL;
8244 }
8245
8246
8247 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8248 PyObject *resultobj = 0;
8249 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8250 double arg2 ;
8251 void *argp1 = 0 ;
8252 int res1 = 0 ;
8253 double val2 ;
8254 int ecode2 = 0 ;
8255 PyObject * obj0 = 0 ;
8256 PyObject * obj1 = 0 ;
8257 char * kwnames[] = {
8258 (char *) "self",(char *) "length", NULL
8259 };
8260
8261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8263 if (!SWIG_IsOK(res1)) {
8264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8265 }
8266 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8267 ecode2 = SWIG_AsVal_double(obj1, &val2);
8268 if (!SWIG_IsOK(ecode2)) {
8269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8270 }
8271 arg2 = static_cast< double >(val2);
8272 {
8273 PyThreadState* __tstate = wxPyBeginAllowThreads();
8274 (arg1)->SetVectorLength(arg2);
8275 wxPyEndAllowThreads(__tstate);
8276 if (PyErr_Occurred()) SWIG_fail;
8277 }
8278 resultobj = SWIG_Py_Void();
8279 return resultobj;
8280 fail:
8281 return NULL;
8282 }
8283
8284
8285 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8286 PyObject *resultobj = 0;
8287 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8288 double arg2 ;
8289 void *argp1 = 0 ;
8290 int res1 = 0 ;
8291 double val2 ;
8292 int ecode2 = 0 ;
8293 PyObject * obj0 = 0 ;
8294 PyObject * obj1 = 0 ;
8295 char * kwnames[] = {
8296 (char *) "self",(char *) "degrees", NULL
8297 };
8298
8299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8301 if (!SWIG_IsOK(res1)) {
8302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8303 }
8304 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8305 ecode2 = SWIG_AsVal_double(obj1, &val2);
8306 if (!SWIG_IsOK(ecode2)) {
8307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8308 }
8309 arg2 = static_cast< double >(val2);
8310 {
8311 PyThreadState* __tstate = wxPyBeginAllowThreads();
8312 (arg1)->SetVectorAngle(arg2);
8313 wxPyEndAllowThreads(__tstate);
8314 if (PyErr_Occurred()) SWIG_fail;
8315 }
8316 resultobj = SWIG_Py_Void();
8317 return resultobj;
8318 fail:
8319 return NULL;
8320 }
8321
8322
8323 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8324 PyObject *resultobj = 0;
8325 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8326 wxPoint2D *arg2 = 0 ;
8327 double result;
8328 void *argp1 = 0 ;
8329 int res1 = 0 ;
8330 wxPoint2D temp2 ;
8331 PyObject * obj0 = 0 ;
8332 PyObject * obj1 = 0 ;
8333 char * kwnames[] = {
8334 (char *) "self",(char *) "pt", NULL
8335 };
8336
8337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8339 if (!SWIG_IsOK(res1)) {
8340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8341 }
8342 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8343 {
8344 arg2 = &temp2;
8345 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8346 }
8347 {
8348 PyThreadState* __tstate = wxPyBeginAllowThreads();
8349 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8350 wxPyEndAllowThreads(__tstate);
8351 if (PyErr_Occurred()) SWIG_fail;
8352 }
8353 resultobj = SWIG_From_double(static_cast< double >(result));
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj = 0;
8362 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8363 wxPoint2D *arg2 = 0 ;
8364 double result;
8365 void *argp1 = 0 ;
8366 int res1 = 0 ;
8367 wxPoint2D temp2 ;
8368 PyObject * obj0 = 0 ;
8369 PyObject * obj1 = 0 ;
8370 char * kwnames[] = {
8371 (char *) "self",(char *) "pt", NULL
8372 };
8373
8374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8376 if (!SWIG_IsOK(res1)) {
8377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8378 }
8379 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8380 {
8381 arg2 = &temp2;
8382 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8383 }
8384 {
8385 PyThreadState* __tstate = wxPyBeginAllowThreads();
8386 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8387 wxPyEndAllowThreads(__tstate);
8388 if (PyErr_Occurred()) SWIG_fail;
8389 }
8390 resultobj = SWIG_From_double(static_cast< double >(result));
8391 return resultobj;
8392 fail:
8393 return NULL;
8394 }
8395
8396
8397 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(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 *) "vec", NULL
8409 };
8410
8411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",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_GetDotProduct" "', 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)->GetDotProduct((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_GetCrossProduct(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 *) "vec", NULL
8446 };
8447
8448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",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_GetCrossProduct" "', 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)->GetCrossProduct((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___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8472 PyObject *resultobj = 0;
8473 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8474 wxPoint2D result;
8475 void *argp1 = 0 ;
8476 int res1 = 0 ;
8477 PyObject *swig_obj[1] ;
8478
8479 if (!args) SWIG_fail;
8480 swig_obj[0] = args;
8481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8482 if (!SWIG_IsOK(res1)) {
8483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8484 }
8485 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8486 {
8487 PyThreadState* __tstate = wxPyBeginAllowThreads();
8488 result = (arg1)->operator -();
8489 wxPyEndAllowThreads(__tstate);
8490 if (PyErr_Occurred()) SWIG_fail;
8491 }
8492 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8493 return resultobj;
8494 fail:
8495 return NULL;
8496 }
8497
8498
8499 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8500 PyObject *resultobj = 0;
8501 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8502 wxPoint2D *arg2 = 0 ;
8503 wxPoint2D *result = 0 ;
8504 void *argp1 = 0 ;
8505 int res1 = 0 ;
8506 wxPoint2D temp2 ;
8507 PyObject * obj0 = 0 ;
8508 PyObject * obj1 = 0 ;
8509 char * kwnames[] = {
8510 (char *) "self",(char *) "pt", NULL
8511 };
8512
8513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8515 if (!SWIG_IsOK(res1)) {
8516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8517 }
8518 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8519 {
8520 arg2 = &temp2;
8521 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8522 }
8523 {
8524 PyThreadState* __tstate = wxPyBeginAllowThreads();
8525 {
8526 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8527 result = (wxPoint2D *) &_result_ref;
8528 }
8529 wxPyEndAllowThreads(__tstate);
8530 if (PyErr_Occurred()) SWIG_fail;
8531 }
8532 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8533 return resultobj;
8534 fail:
8535 return NULL;
8536 }
8537
8538
8539 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8540 PyObject *resultobj = 0;
8541 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8542 wxPoint2D *arg2 = 0 ;
8543 wxPoint2D *result = 0 ;
8544 void *argp1 = 0 ;
8545 int res1 = 0 ;
8546 wxPoint2D temp2 ;
8547 PyObject * obj0 = 0 ;
8548 PyObject * obj1 = 0 ;
8549 char * kwnames[] = {
8550 (char *) "self",(char *) "pt", NULL
8551 };
8552
8553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8555 if (!SWIG_IsOK(res1)) {
8556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8557 }
8558 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8559 {
8560 arg2 = &temp2;
8561 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8562 }
8563 {
8564 PyThreadState* __tstate = wxPyBeginAllowThreads();
8565 {
8566 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8567 result = (wxPoint2D *) &_result_ref;
8568 }
8569 wxPyEndAllowThreads(__tstate);
8570 if (PyErr_Occurred()) SWIG_fail;
8571 }
8572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8573 return resultobj;
8574 fail:
8575 return NULL;
8576 }
8577
8578
8579 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8580 PyObject *resultobj = 0;
8581 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8582 wxPoint2D *arg2 = 0 ;
8583 wxPoint2D *result = 0 ;
8584 void *argp1 = 0 ;
8585 int res1 = 0 ;
8586 wxPoint2D temp2 ;
8587 PyObject * obj0 = 0 ;
8588 PyObject * obj1 = 0 ;
8589 char * kwnames[] = {
8590 (char *) "self",(char *) "pt", NULL
8591 };
8592
8593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8595 if (!SWIG_IsOK(res1)) {
8596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8597 }
8598 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8599 {
8600 arg2 = &temp2;
8601 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8602 }
8603 {
8604 PyThreadState* __tstate = wxPyBeginAllowThreads();
8605 {
8606 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8607 result = (wxPoint2D *) &_result_ref;
8608 }
8609 wxPyEndAllowThreads(__tstate);
8610 if (PyErr_Occurred()) SWIG_fail;
8611 }
8612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8613 return resultobj;
8614 fail:
8615 return NULL;
8616 }
8617
8618
8619 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8620 PyObject *resultobj = 0;
8621 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8622 wxPoint2D *arg2 = 0 ;
8623 wxPoint2D *result = 0 ;
8624 void *argp1 = 0 ;
8625 int res1 = 0 ;
8626 wxPoint2D temp2 ;
8627 PyObject * obj0 = 0 ;
8628 PyObject * obj1 = 0 ;
8629 char * kwnames[] = {
8630 (char *) "self",(char *) "pt", NULL
8631 };
8632
8633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8635 if (!SWIG_IsOK(res1)) {
8636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8637 }
8638 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8639 {
8640 arg2 = &temp2;
8641 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8642 }
8643 {
8644 PyThreadState* __tstate = wxPyBeginAllowThreads();
8645 {
8646 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8647 result = (wxPoint2D *) &_result_ref;
8648 }
8649 wxPyEndAllowThreads(__tstate);
8650 if (PyErr_Occurred()) SWIG_fail;
8651 }
8652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8653 return resultobj;
8654 fail:
8655 return NULL;
8656 }
8657
8658
8659 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8660 PyObject *resultobj = 0;
8661 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8662 PyObject *arg2 = (PyObject *) 0 ;
8663 bool result;
8664 void *argp1 = 0 ;
8665 int res1 = 0 ;
8666 PyObject * obj0 = 0 ;
8667 PyObject * obj1 = 0 ;
8668 char * kwnames[] = {
8669 (char *) "self",(char *) "other", NULL
8670 };
8671
8672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8674 if (!SWIG_IsOK(res1)) {
8675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8676 }
8677 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8678 arg2 = obj1;
8679 {
8680 result = (bool)wxPoint2D___eq__(arg1,arg2);
8681 if (PyErr_Occurred()) SWIG_fail;
8682 }
8683 {
8684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8685 }
8686 return resultobj;
8687 fail:
8688 return NULL;
8689 }
8690
8691
8692 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8693 PyObject *resultobj = 0;
8694 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8695 PyObject *arg2 = (PyObject *) 0 ;
8696 bool result;
8697 void *argp1 = 0 ;
8698 int res1 = 0 ;
8699 PyObject * obj0 = 0 ;
8700 PyObject * obj1 = 0 ;
8701 char * kwnames[] = {
8702 (char *) "self",(char *) "other", NULL
8703 };
8704
8705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8707 if (!SWIG_IsOK(res1)) {
8708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8709 }
8710 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8711 arg2 = obj1;
8712 {
8713 result = (bool)wxPoint2D___ne__(arg1,arg2);
8714 if (PyErr_Occurred()) SWIG_fail;
8715 }
8716 {
8717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8718 }
8719 return resultobj;
8720 fail:
8721 return NULL;
8722 }
8723
8724
8725 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8726 PyObject *resultobj = 0;
8727 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8728 double arg2 ;
8729 void *argp1 = 0 ;
8730 int res1 = 0 ;
8731 double val2 ;
8732 int ecode2 = 0 ;
8733 PyObject *swig_obj[2] ;
8734
8735 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8737 if (!SWIG_IsOK(res1)) {
8738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8739 }
8740 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8741 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8742 if (!SWIG_IsOK(ecode2)) {
8743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8744 }
8745 arg2 = static_cast< double >(val2);
8746 if (arg1) (arg1)->m_x = arg2;
8747
8748 resultobj = SWIG_Py_Void();
8749 return resultobj;
8750 fail:
8751 return NULL;
8752 }
8753
8754
8755 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8756 PyObject *resultobj = 0;
8757 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8758 double result;
8759 void *argp1 = 0 ;
8760 int res1 = 0 ;
8761 PyObject *swig_obj[1] ;
8762
8763 if (!args) SWIG_fail;
8764 swig_obj[0] = args;
8765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8766 if (!SWIG_IsOK(res1)) {
8767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8768 }
8769 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8770 result = (double) ((arg1)->m_x);
8771 resultobj = SWIG_From_double(static_cast< double >(result));
8772 return resultobj;
8773 fail:
8774 return NULL;
8775 }
8776
8777
8778 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8779 PyObject *resultobj = 0;
8780 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8781 double arg2 ;
8782 void *argp1 = 0 ;
8783 int res1 = 0 ;
8784 double val2 ;
8785 int ecode2 = 0 ;
8786 PyObject *swig_obj[2] ;
8787
8788 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8790 if (!SWIG_IsOK(res1)) {
8791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8792 }
8793 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8794 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8795 if (!SWIG_IsOK(ecode2)) {
8796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8797 }
8798 arg2 = static_cast< double >(val2);
8799 if (arg1) (arg1)->m_y = arg2;
8800
8801 resultobj = SWIG_Py_Void();
8802 return resultobj;
8803 fail:
8804 return NULL;
8805 }
8806
8807
8808 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8809 PyObject *resultobj = 0;
8810 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8811 double result;
8812 void *argp1 = 0 ;
8813 int res1 = 0 ;
8814 PyObject *swig_obj[1] ;
8815
8816 if (!args) SWIG_fail;
8817 swig_obj[0] = args;
8818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8819 if (!SWIG_IsOK(res1)) {
8820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8821 }
8822 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8823 result = (double) ((arg1)->m_y);
8824 resultobj = SWIG_From_double(static_cast< double >(result));
8825 return resultobj;
8826 fail:
8827 return NULL;
8828 }
8829
8830
8831 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8832 PyObject *resultobj = 0;
8833 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8834 double arg2 = (double) 0 ;
8835 double arg3 = (double) 0 ;
8836 void *argp1 = 0 ;
8837 int res1 = 0 ;
8838 double val2 ;
8839 int ecode2 = 0 ;
8840 double val3 ;
8841 int ecode3 = 0 ;
8842 PyObject * obj0 = 0 ;
8843 PyObject * obj1 = 0 ;
8844 PyObject * obj2 = 0 ;
8845 char * kwnames[] = {
8846 (char *) "self",(char *) "x",(char *) "y", NULL
8847 };
8848
8849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8851 if (!SWIG_IsOK(res1)) {
8852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8853 }
8854 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8855 if (obj1) {
8856 ecode2 = SWIG_AsVal_double(obj1, &val2);
8857 if (!SWIG_IsOK(ecode2)) {
8858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8859 }
8860 arg2 = static_cast< double >(val2);
8861 }
8862 if (obj2) {
8863 ecode3 = SWIG_AsVal_double(obj2, &val3);
8864 if (!SWIG_IsOK(ecode3)) {
8865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8866 }
8867 arg3 = static_cast< double >(val3);
8868 }
8869 {
8870 PyThreadState* __tstate = wxPyBeginAllowThreads();
8871 wxPoint2D_Set(arg1,arg2,arg3);
8872 wxPyEndAllowThreads(__tstate);
8873 if (PyErr_Occurred()) SWIG_fail;
8874 }
8875 resultobj = SWIG_Py_Void();
8876 return resultobj;
8877 fail:
8878 return NULL;
8879 }
8880
8881
8882 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8883 PyObject *resultobj = 0;
8884 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8885 PyObject *result = 0 ;
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_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8895 }
8896 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8897 {
8898 PyThreadState* __tstate = wxPyBeginAllowThreads();
8899 result = (PyObject *)wxPoint2D_Get(arg1);
8900 wxPyEndAllowThreads(__tstate);
8901 if (PyErr_Occurred()) SWIG_fail;
8902 }
8903 resultobj = result;
8904 return resultobj;
8905 fail:
8906 return NULL;
8907 }
8908
8909
8910 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8911 PyObject *obj;
8912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8913 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8914 return SWIG_Py_Void();
8915 }
8916
8917 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8918 return SWIG_Python_InitShadowInstance(args);
8919 }
8920
8921 SWIGINTERN int DefaultPosition_set(PyObject *) {
8922 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8923 return 1;
8924 }
8925
8926
8927 SWIGINTERN PyObject *DefaultPosition_get(void) {
8928 PyObject *pyobj = 0;
8929
8930 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8931 return pyobj;
8932 }
8933
8934
8935 SWIGINTERN int DefaultSize_set(PyObject *) {
8936 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8937 return 1;
8938 }
8939
8940
8941 SWIGINTERN PyObject *DefaultSize_get(void) {
8942 PyObject *pyobj = 0;
8943
8944 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8945 return pyobj;
8946 }
8947
8948
8949 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8950 PyObject *resultobj = 0;
8951 PyObject *arg1 = (PyObject *) 0 ;
8952 wxPyInputStream *result = 0 ;
8953 PyObject * obj0 = 0 ;
8954 char * kwnames[] = {
8955 (char *) "p", NULL
8956 };
8957
8958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8959 arg1 = obj0;
8960 {
8961 PyThreadState* __tstate = wxPyBeginAllowThreads();
8962 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8963 wxPyEndAllowThreads(__tstate);
8964 if (PyErr_Occurred()) SWIG_fail;
8965 }
8966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8967 return resultobj;
8968 fail:
8969 return NULL;
8970 }
8971
8972
8973 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8974 PyObject *resultobj = 0;
8975 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8976 void *argp1 = 0 ;
8977 int res1 = 0 ;
8978 PyObject *swig_obj[1] ;
8979
8980 if (!args) SWIG_fail;
8981 swig_obj[0] = args;
8982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8983 if (!SWIG_IsOK(res1)) {
8984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8985 }
8986 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8987 {
8988 PyThreadState* __tstate = wxPyBeginAllowThreads();
8989 delete arg1;
8990
8991 wxPyEndAllowThreads(__tstate);
8992 if (PyErr_Occurred()) SWIG_fail;
8993 }
8994 resultobj = SWIG_Py_Void();
8995 return resultobj;
8996 fail:
8997 return NULL;
8998 }
8999
9000
9001 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9002 PyObject *resultobj = 0;
9003 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9004 void *argp1 = 0 ;
9005 int res1 = 0 ;
9006 PyObject *swig_obj[1] ;
9007
9008 if (!args) SWIG_fail;
9009 swig_obj[0] = args;
9010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9011 if (!SWIG_IsOK(res1)) {
9012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9013 }
9014 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9015 {
9016 PyThreadState* __tstate = wxPyBeginAllowThreads();
9017 (arg1)->close();
9018 wxPyEndAllowThreads(__tstate);
9019 if (PyErr_Occurred()) SWIG_fail;
9020 }
9021 resultobj = SWIG_Py_Void();
9022 return resultobj;
9023 fail:
9024 return NULL;
9025 }
9026
9027
9028 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9029 PyObject *resultobj = 0;
9030 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9031 void *argp1 = 0 ;
9032 int res1 = 0 ;
9033 PyObject *swig_obj[1] ;
9034
9035 if (!args) SWIG_fail;
9036 swig_obj[0] = args;
9037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9038 if (!SWIG_IsOK(res1)) {
9039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9040 }
9041 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9042 {
9043 PyThreadState* __tstate = wxPyBeginAllowThreads();
9044 (arg1)->flush();
9045 wxPyEndAllowThreads(__tstate);
9046 if (PyErr_Occurred()) SWIG_fail;
9047 }
9048 resultobj = SWIG_Py_Void();
9049 return resultobj;
9050 fail:
9051 return NULL;
9052 }
9053
9054
9055 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9056 PyObject *resultobj = 0;
9057 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9058 bool result;
9059 void *argp1 = 0 ;
9060 int res1 = 0 ;
9061 PyObject *swig_obj[1] ;
9062
9063 if (!args) SWIG_fail;
9064 swig_obj[0] = args;
9065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9066 if (!SWIG_IsOK(res1)) {
9067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9068 }
9069 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9070 {
9071 PyThreadState* __tstate = wxPyBeginAllowThreads();
9072 result = (bool)(arg1)->eof();
9073 wxPyEndAllowThreads(__tstate);
9074 if (PyErr_Occurred()) SWIG_fail;
9075 }
9076 {
9077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9078 }
9079 return resultobj;
9080 fail:
9081 return NULL;
9082 }
9083
9084
9085 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9086 PyObject *resultobj = 0;
9087 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9088 int arg2 = (int) -1 ;
9089 PyObject *result = 0 ;
9090 void *argp1 = 0 ;
9091 int res1 = 0 ;
9092 int val2 ;
9093 int ecode2 = 0 ;
9094 PyObject * obj0 = 0 ;
9095 PyObject * obj1 = 0 ;
9096 char * kwnames[] = {
9097 (char *) "self",(char *) "size", NULL
9098 };
9099
9100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9102 if (!SWIG_IsOK(res1)) {
9103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9104 }
9105 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9106 if (obj1) {
9107 ecode2 = SWIG_AsVal_int(obj1, &val2);
9108 if (!SWIG_IsOK(ecode2)) {
9109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9110 }
9111 arg2 = static_cast< int >(val2);
9112 }
9113 {
9114 PyThreadState* __tstate = wxPyBeginAllowThreads();
9115 result = (PyObject *)(arg1)->read(arg2);
9116 wxPyEndAllowThreads(__tstate);
9117 if (PyErr_Occurred()) SWIG_fail;
9118 }
9119 resultobj = result;
9120 return resultobj;
9121 fail:
9122 return NULL;
9123 }
9124
9125
9126 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9127 PyObject *resultobj = 0;
9128 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9129 int arg2 = (int) -1 ;
9130 PyObject *result = 0 ;
9131 void *argp1 = 0 ;
9132 int res1 = 0 ;
9133 int val2 ;
9134 int ecode2 = 0 ;
9135 PyObject * obj0 = 0 ;
9136 PyObject * obj1 = 0 ;
9137 char * kwnames[] = {
9138 (char *) "self",(char *) "size", NULL
9139 };
9140
9141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9143 if (!SWIG_IsOK(res1)) {
9144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9145 }
9146 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9147 if (obj1) {
9148 ecode2 = SWIG_AsVal_int(obj1, &val2);
9149 if (!SWIG_IsOK(ecode2)) {
9150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9151 }
9152 arg2 = static_cast< int >(val2);
9153 }
9154 {
9155 PyThreadState* __tstate = wxPyBeginAllowThreads();
9156 result = (PyObject *)(arg1)->readline(arg2);
9157 wxPyEndAllowThreads(__tstate);
9158 if (PyErr_Occurred()) SWIG_fail;
9159 }
9160 resultobj = result;
9161 return resultobj;
9162 fail:
9163 return NULL;
9164 }
9165
9166
9167 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9168 PyObject *resultobj = 0;
9169 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9170 int arg2 = (int) -1 ;
9171 PyObject *result = 0 ;
9172 void *argp1 = 0 ;
9173 int res1 = 0 ;
9174 int val2 ;
9175 int ecode2 = 0 ;
9176 PyObject * obj0 = 0 ;
9177 PyObject * obj1 = 0 ;
9178 char * kwnames[] = {
9179 (char *) "self",(char *) "sizehint", NULL
9180 };
9181
9182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9184 if (!SWIG_IsOK(res1)) {
9185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9186 }
9187 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9188 if (obj1) {
9189 ecode2 = SWIG_AsVal_int(obj1, &val2);
9190 if (!SWIG_IsOK(ecode2)) {
9191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9192 }
9193 arg2 = static_cast< int >(val2);
9194 }
9195 {
9196 PyThreadState* __tstate = wxPyBeginAllowThreads();
9197 result = (PyObject *)(arg1)->readlines(arg2);
9198 wxPyEndAllowThreads(__tstate);
9199 if (PyErr_Occurred()) SWIG_fail;
9200 }
9201 resultobj = result;
9202 return resultobj;
9203 fail:
9204 return NULL;
9205 }
9206
9207
9208 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9209 PyObject *resultobj = 0;
9210 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9211 int arg2 ;
9212 int arg3 = (int) 0 ;
9213 void *argp1 = 0 ;
9214 int res1 = 0 ;
9215 int val2 ;
9216 int ecode2 = 0 ;
9217 int val3 ;
9218 int ecode3 = 0 ;
9219 PyObject * obj0 = 0 ;
9220 PyObject * obj1 = 0 ;
9221 PyObject * obj2 = 0 ;
9222 char * kwnames[] = {
9223 (char *) "self",(char *) "offset",(char *) "whence", NULL
9224 };
9225
9226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9228 if (!SWIG_IsOK(res1)) {
9229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9230 }
9231 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9232 ecode2 = SWIG_AsVal_int(obj1, &val2);
9233 if (!SWIG_IsOK(ecode2)) {
9234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9235 }
9236 arg2 = static_cast< int >(val2);
9237 if (obj2) {
9238 ecode3 = SWIG_AsVal_int(obj2, &val3);
9239 if (!SWIG_IsOK(ecode3)) {
9240 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9241 }
9242 arg3 = static_cast< int >(val3);
9243 }
9244 {
9245 PyThreadState* __tstate = wxPyBeginAllowThreads();
9246 (arg1)->seek(arg2,arg3);
9247 wxPyEndAllowThreads(__tstate);
9248 if (PyErr_Occurred()) SWIG_fail;
9249 }
9250 resultobj = SWIG_Py_Void();
9251 return resultobj;
9252 fail:
9253 return NULL;
9254 }
9255
9256
9257 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9258 PyObject *resultobj = 0;
9259 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9260 int result;
9261 void *argp1 = 0 ;
9262 int res1 = 0 ;
9263 PyObject *swig_obj[1] ;
9264
9265 if (!args) SWIG_fail;
9266 swig_obj[0] = args;
9267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9268 if (!SWIG_IsOK(res1)) {
9269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9270 }
9271 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9272 {
9273 PyThreadState* __tstate = wxPyBeginAllowThreads();
9274 result = (int)(arg1)->tell();
9275 wxPyEndAllowThreads(__tstate);
9276 if (PyErr_Occurred()) SWIG_fail;
9277 }
9278 resultobj = SWIG_From_int(static_cast< int >(result));
9279 return resultobj;
9280 fail:
9281 return NULL;
9282 }
9283
9284
9285 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9286 PyObject *resultobj = 0;
9287 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9288 char result;
9289 void *argp1 = 0 ;
9290 int res1 = 0 ;
9291 PyObject *swig_obj[1] ;
9292
9293 if (!args) SWIG_fail;
9294 swig_obj[0] = args;
9295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9296 if (!SWIG_IsOK(res1)) {
9297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9298 }
9299 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9300 {
9301 PyThreadState* __tstate = wxPyBeginAllowThreads();
9302 result = (char)(arg1)->Peek();
9303 wxPyEndAllowThreads(__tstate);
9304 if (PyErr_Occurred()) SWIG_fail;
9305 }
9306 resultobj = SWIG_From_char(static_cast< char >(result));
9307 return resultobj;
9308 fail:
9309 return NULL;
9310 }
9311
9312
9313 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9314 PyObject *resultobj = 0;
9315 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9316 char result;
9317 void *argp1 = 0 ;
9318 int res1 = 0 ;
9319 PyObject *swig_obj[1] ;
9320
9321 if (!args) SWIG_fail;
9322 swig_obj[0] = args;
9323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9324 if (!SWIG_IsOK(res1)) {
9325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9326 }
9327 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9328 {
9329 PyThreadState* __tstate = wxPyBeginAllowThreads();
9330 result = (char)(arg1)->GetC();
9331 wxPyEndAllowThreads(__tstate);
9332 if (PyErr_Occurred()) SWIG_fail;
9333 }
9334 resultobj = SWIG_From_char(static_cast< char >(result));
9335 return resultobj;
9336 fail:
9337 return NULL;
9338 }
9339
9340
9341 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9342 PyObject *resultobj = 0;
9343 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9344 size_t result;
9345 void *argp1 = 0 ;
9346 int res1 = 0 ;
9347 PyObject *swig_obj[1] ;
9348
9349 if (!args) SWIG_fail;
9350 swig_obj[0] = args;
9351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9352 if (!SWIG_IsOK(res1)) {
9353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9354 }
9355 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9356 {
9357 PyThreadState* __tstate = wxPyBeginAllowThreads();
9358 result = (size_t)(arg1)->LastRead();
9359 wxPyEndAllowThreads(__tstate);
9360 if (PyErr_Occurred()) SWIG_fail;
9361 }
9362 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9363 return resultobj;
9364 fail:
9365 return NULL;
9366 }
9367
9368
9369 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9370 PyObject *resultobj = 0;
9371 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9372 bool result;
9373 void *argp1 = 0 ;
9374 int res1 = 0 ;
9375 PyObject *swig_obj[1] ;
9376
9377 if (!args) SWIG_fail;
9378 swig_obj[0] = args;
9379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9380 if (!SWIG_IsOK(res1)) {
9381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9382 }
9383 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9384 {
9385 PyThreadState* __tstate = wxPyBeginAllowThreads();
9386 result = (bool)(arg1)->CanRead();
9387 wxPyEndAllowThreads(__tstate);
9388 if (PyErr_Occurred()) SWIG_fail;
9389 }
9390 {
9391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9392 }
9393 return resultobj;
9394 fail:
9395 return NULL;
9396 }
9397
9398
9399 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9400 PyObject *resultobj = 0;
9401 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9402 bool result;
9403 void *argp1 = 0 ;
9404 int res1 = 0 ;
9405 PyObject *swig_obj[1] ;
9406
9407 if (!args) SWIG_fail;
9408 swig_obj[0] = args;
9409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9410 if (!SWIG_IsOK(res1)) {
9411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9412 }
9413 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9414 {
9415 PyThreadState* __tstate = wxPyBeginAllowThreads();
9416 result = (bool)(arg1)->Eof();
9417 wxPyEndAllowThreads(__tstate);
9418 if (PyErr_Occurred()) SWIG_fail;
9419 }
9420 {
9421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9422 }
9423 return resultobj;
9424 fail:
9425 return NULL;
9426 }
9427
9428
9429 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9430 PyObject *resultobj = 0;
9431 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9432 char arg2 ;
9433 bool result;
9434 void *argp1 = 0 ;
9435 int res1 = 0 ;
9436 char val2 ;
9437 int ecode2 = 0 ;
9438 PyObject * obj0 = 0 ;
9439 PyObject * obj1 = 0 ;
9440 char * kwnames[] = {
9441 (char *) "self",(char *) "c", NULL
9442 };
9443
9444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9446 if (!SWIG_IsOK(res1)) {
9447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9448 }
9449 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9450 ecode2 = SWIG_AsVal_char(obj1, &val2);
9451 if (!SWIG_IsOK(ecode2)) {
9452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9453 }
9454 arg2 = static_cast< char >(val2);
9455 {
9456 PyThreadState* __tstate = wxPyBeginAllowThreads();
9457 result = (bool)(arg1)->Ungetch(arg2);
9458 wxPyEndAllowThreads(__tstate);
9459 if (PyErr_Occurred()) SWIG_fail;
9460 }
9461 {
9462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9463 }
9464 return resultobj;
9465 fail:
9466 return NULL;
9467 }
9468
9469
9470 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9471 PyObject *resultobj = 0;
9472 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9473 long arg2 ;
9474 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9475 long result;
9476 void *argp1 = 0 ;
9477 int res1 = 0 ;
9478 long val2 ;
9479 int ecode2 = 0 ;
9480 int val3 ;
9481 int ecode3 = 0 ;
9482 PyObject * obj0 = 0 ;
9483 PyObject * obj1 = 0 ;
9484 PyObject * obj2 = 0 ;
9485 char * kwnames[] = {
9486 (char *) "self",(char *) "pos",(char *) "mode", NULL
9487 };
9488
9489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9491 if (!SWIG_IsOK(res1)) {
9492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9493 }
9494 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9495 ecode2 = SWIG_AsVal_long(obj1, &val2);
9496 if (!SWIG_IsOK(ecode2)) {
9497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9498 }
9499 arg2 = static_cast< long >(val2);
9500 if (obj2) {
9501 ecode3 = SWIG_AsVal_int(obj2, &val3);
9502 if (!SWIG_IsOK(ecode3)) {
9503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9504 }
9505 arg3 = static_cast< wxSeekMode >(val3);
9506 }
9507 {
9508 PyThreadState* __tstate = wxPyBeginAllowThreads();
9509 result = (long)(arg1)->SeekI(arg2,arg3);
9510 wxPyEndAllowThreads(__tstate);
9511 if (PyErr_Occurred()) SWIG_fail;
9512 }
9513 resultobj = SWIG_From_long(static_cast< long >(result));
9514 return resultobj;
9515 fail:
9516 return NULL;
9517 }
9518
9519
9520 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9521 PyObject *resultobj = 0;
9522 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9523 long result;
9524 void *argp1 = 0 ;
9525 int res1 = 0 ;
9526 PyObject *swig_obj[1] ;
9527
9528 if (!args) SWIG_fail;
9529 swig_obj[0] = args;
9530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9531 if (!SWIG_IsOK(res1)) {
9532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9533 }
9534 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9535 {
9536 PyThreadState* __tstate = wxPyBeginAllowThreads();
9537 result = (long)(arg1)->TellI();
9538 wxPyEndAllowThreads(__tstate);
9539 if (PyErr_Occurred()) SWIG_fail;
9540 }
9541 resultobj = SWIG_From_long(static_cast< long >(result));
9542 return resultobj;
9543 fail:
9544 return NULL;
9545 }
9546
9547
9548 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9549 PyObject *obj;
9550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9551 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9552 return SWIG_Py_Void();
9553 }
9554
9555 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9556 return SWIG_Python_InitShadowInstance(args);
9557 }
9558
9559 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9560 PyObject *resultobj = 0;
9561 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9562 PyObject *arg2 = (PyObject *) 0 ;
9563 void *argp1 = 0 ;
9564 int res1 = 0 ;
9565 PyObject * obj0 = 0 ;
9566 PyObject * obj1 = 0 ;
9567 char * kwnames[] = {
9568 (char *) "self",(char *) "obj", NULL
9569 };
9570
9571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9573 if (!SWIG_IsOK(res1)) {
9574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9575 }
9576 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9577 arg2 = obj1;
9578 {
9579 PyThreadState* __tstate = wxPyBeginAllowThreads();
9580 wxOutputStream_write(arg1,arg2);
9581 wxPyEndAllowThreads(__tstate);
9582 if (PyErr_Occurred()) SWIG_fail;
9583 }
9584 resultobj = SWIG_Py_Void();
9585 return resultobj;
9586 fail:
9587 return NULL;
9588 }
9589
9590
9591 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9592 PyObject *resultobj = 0;
9593 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9594 size_t result;
9595 void *argp1 = 0 ;
9596 int res1 = 0 ;
9597 PyObject *swig_obj[1] ;
9598
9599 if (!args) SWIG_fail;
9600 swig_obj[0] = args;
9601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9602 if (!SWIG_IsOK(res1)) {
9603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9604 }
9605 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9606 {
9607 PyThreadState* __tstate = wxPyBeginAllowThreads();
9608 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9609 wxPyEndAllowThreads(__tstate);
9610 if (PyErr_Occurred()) SWIG_fail;
9611 }
9612 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9613 return resultobj;
9614 fail:
9615 return NULL;
9616 }
9617
9618
9619 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9620 PyObject *obj;
9621 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9622 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9623 return SWIG_Py_Void();
9624 }
9625
9626 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9627 PyObject *resultobj = 0;
9628 wxInputStream *arg1 = (wxInputStream *) 0 ;
9629 wxString *arg2 = 0 ;
9630 wxString *arg3 = 0 ;
9631 wxString *arg4 = 0 ;
9632 wxDateTime arg5 ;
9633 wxFSFile *result = 0 ;
9634 wxPyInputStream *temp1 ;
9635 bool temp2 = false ;
9636 bool temp3 = false ;
9637 bool temp4 = false ;
9638 void *argp5 ;
9639 int res5 = 0 ;
9640 PyObject * obj0 = 0 ;
9641 PyObject * obj1 = 0 ;
9642 PyObject * obj2 = 0 ;
9643 PyObject * obj3 = 0 ;
9644 PyObject * obj4 = 0 ;
9645 char * kwnames[] = {
9646 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9647 };
9648
9649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9650 {
9651 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9652 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9653 } else {
9654 PyErr_Clear(); // clear the failure of the wxPyConvert above
9655 arg1 = wxPyCBInputStream_create(obj0, true);
9656 if (arg1 == NULL) {
9657 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9658 SWIG_fail;
9659 }
9660 }
9661 }
9662 {
9663 arg2 = wxString_in_helper(obj1);
9664 if (arg2 == NULL) SWIG_fail;
9665 temp2 = true;
9666 }
9667 {
9668 arg3 = wxString_in_helper(obj2);
9669 if (arg3 == NULL) SWIG_fail;
9670 temp3 = true;
9671 }
9672 {
9673 arg4 = wxString_in_helper(obj3);
9674 if (arg4 == NULL) SWIG_fail;
9675 temp4 = true;
9676 }
9677 {
9678 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9679 if (!SWIG_IsOK(res5)) {
9680 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9681 }
9682 if (!argp5) {
9683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9684 } else {
9685 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9686 arg5 = *temp;
9687 if (SWIG_IsNewObj(res5)) delete temp;
9688 }
9689 }
9690 {
9691 PyThreadState* __tstate = wxPyBeginAllowThreads();
9692 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9693 wxPyEndAllowThreads(__tstate);
9694 if (PyErr_Occurred()) SWIG_fail;
9695 }
9696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9697 {
9698 if (temp2)
9699 delete arg2;
9700 }
9701 {
9702 if (temp3)
9703 delete arg3;
9704 }
9705 {
9706 if (temp4)
9707 delete arg4;
9708 }
9709 return resultobj;
9710 fail:
9711 {
9712 if (temp2)
9713 delete arg2;
9714 }
9715 {
9716 if (temp3)
9717 delete arg3;
9718 }
9719 {
9720 if (temp4)
9721 delete arg4;
9722 }
9723 return NULL;
9724 }
9725
9726
9727 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9728 PyObject *resultobj = 0;
9729 wxFSFile *arg1 = (wxFSFile *) 0 ;
9730 void *argp1 = 0 ;
9731 int res1 = 0 ;
9732 PyObject *swig_obj[1] ;
9733
9734 if (!args) SWIG_fail;
9735 swig_obj[0] = args;
9736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9737 if (!SWIG_IsOK(res1)) {
9738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9739 }
9740 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9741 {
9742 PyThreadState* __tstate = wxPyBeginAllowThreads();
9743 delete arg1;
9744
9745 wxPyEndAllowThreads(__tstate);
9746 if (PyErr_Occurred()) SWIG_fail;
9747 }
9748 resultobj = SWIG_Py_Void();
9749 return resultobj;
9750 fail:
9751 return NULL;
9752 }
9753
9754
9755 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9756 PyObject *resultobj = 0;
9757 wxFSFile *arg1 = (wxFSFile *) 0 ;
9758 wxInputStream *result = 0 ;
9759 void *argp1 = 0 ;
9760 int res1 = 0 ;
9761 PyObject *swig_obj[1] ;
9762
9763 if (!args) SWIG_fail;
9764 swig_obj[0] = args;
9765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9766 if (!SWIG_IsOK(res1)) {
9767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9768 }
9769 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9770 {
9771 PyThreadState* __tstate = wxPyBeginAllowThreads();
9772 result = (wxInputStream *)(arg1)->GetStream();
9773 wxPyEndAllowThreads(__tstate);
9774 if (PyErr_Occurred()) SWIG_fail;
9775 }
9776 {
9777 wxPyInputStream * _ptr = NULL;
9778
9779 if (result) {
9780 _ptr = new wxPyInputStream(result);
9781 }
9782 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9783 }
9784 return resultobj;
9785 fail:
9786 return NULL;
9787 }
9788
9789
9790 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9791 PyObject *resultobj = 0;
9792 wxFSFile *arg1 = (wxFSFile *) 0 ;
9793 wxString *result = 0 ;
9794 void *argp1 = 0 ;
9795 int res1 = 0 ;
9796 PyObject *swig_obj[1] ;
9797
9798 if (!args) SWIG_fail;
9799 swig_obj[0] = args;
9800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9801 if (!SWIG_IsOK(res1)) {
9802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9803 }
9804 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9805 {
9806 PyThreadState* __tstate = wxPyBeginAllowThreads();
9807 {
9808 wxString const &_result_ref = (arg1)->GetMimeType();
9809 result = (wxString *) &_result_ref;
9810 }
9811 wxPyEndAllowThreads(__tstate);
9812 if (PyErr_Occurred()) SWIG_fail;
9813 }
9814 {
9815 #if wxUSE_UNICODE
9816 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9817 #else
9818 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9819 #endif
9820 }
9821 return resultobj;
9822 fail:
9823 return NULL;
9824 }
9825
9826
9827 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9828 PyObject *resultobj = 0;
9829 wxFSFile *arg1 = (wxFSFile *) 0 ;
9830 wxString *result = 0 ;
9831 void *argp1 = 0 ;
9832 int res1 = 0 ;
9833 PyObject *swig_obj[1] ;
9834
9835 if (!args) SWIG_fail;
9836 swig_obj[0] = args;
9837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9838 if (!SWIG_IsOK(res1)) {
9839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9840 }
9841 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9842 {
9843 PyThreadState* __tstate = wxPyBeginAllowThreads();
9844 {
9845 wxString const &_result_ref = (arg1)->GetLocation();
9846 result = (wxString *) &_result_ref;
9847 }
9848 wxPyEndAllowThreads(__tstate);
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 {
9852 #if wxUSE_UNICODE
9853 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9854 #else
9855 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9856 #endif
9857 }
9858 return resultobj;
9859 fail:
9860 return NULL;
9861 }
9862
9863
9864 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9865 PyObject *resultobj = 0;
9866 wxFSFile *arg1 = (wxFSFile *) 0 ;
9867 wxString *result = 0 ;
9868 void *argp1 = 0 ;
9869 int res1 = 0 ;
9870 PyObject *swig_obj[1] ;
9871
9872 if (!args) SWIG_fail;
9873 swig_obj[0] = args;
9874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9875 if (!SWIG_IsOK(res1)) {
9876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9877 }
9878 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9879 {
9880 PyThreadState* __tstate = wxPyBeginAllowThreads();
9881 {
9882 wxString const &_result_ref = (arg1)->GetAnchor();
9883 result = (wxString *) &_result_ref;
9884 }
9885 wxPyEndAllowThreads(__tstate);
9886 if (PyErr_Occurred()) SWIG_fail;
9887 }
9888 {
9889 #if wxUSE_UNICODE
9890 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9891 #else
9892 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9893 #endif
9894 }
9895 return resultobj;
9896 fail:
9897 return NULL;
9898 }
9899
9900
9901 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9902 PyObject *resultobj = 0;
9903 wxFSFile *arg1 = (wxFSFile *) 0 ;
9904 wxDateTime result;
9905 void *argp1 = 0 ;
9906 int res1 = 0 ;
9907 PyObject *swig_obj[1] ;
9908
9909 if (!args) SWIG_fail;
9910 swig_obj[0] = args;
9911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9912 if (!SWIG_IsOK(res1)) {
9913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9914 }
9915 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9916 {
9917 PyThreadState* __tstate = wxPyBeginAllowThreads();
9918 result = (arg1)->GetModificationTime();
9919 wxPyEndAllowThreads(__tstate);
9920 if (PyErr_Occurred()) SWIG_fail;
9921 }
9922 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9930 PyObject *obj;
9931 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9932 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9933 return SWIG_Py_Void();
9934 }
9935
9936 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9937 return SWIG_Python_InitShadowInstance(args);
9938 }
9939
9940 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9941 PyObject *resultobj = 0;
9942 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9943 void *argp1 = 0 ;
9944 int res1 = 0 ;
9945 PyObject *swig_obj[1] ;
9946
9947 if (!args) SWIG_fail;
9948 swig_obj[0] = args;
9949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9950 if (!SWIG_IsOK(res1)) {
9951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9952 }
9953 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9954 {
9955 PyThreadState* __tstate = wxPyBeginAllowThreads();
9956 delete arg1;
9957
9958 wxPyEndAllowThreads(__tstate);
9959 if (PyErr_Occurred()) SWIG_fail;
9960 }
9961 resultobj = SWIG_Py_Void();
9962 return resultobj;
9963 fail:
9964 return NULL;
9965 }
9966
9967
9968 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9969 PyObject *obj;
9970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9971 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9972 return SWIG_Py_Void();
9973 }
9974
9975 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9976 PyObject *resultobj = 0;
9977 wxPyFileSystemHandler *result = 0 ;
9978
9979 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9980 {
9981 PyThreadState* __tstate = wxPyBeginAllowThreads();
9982 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9983 wxPyEndAllowThreads(__tstate);
9984 if (PyErr_Occurred()) SWIG_fail;
9985 }
9986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9987 return resultobj;
9988 fail:
9989 return NULL;
9990 }
9991
9992
9993 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9994 PyObject *resultobj = 0;
9995 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9996 PyObject *arg2 = (PyObject *) 0 ;
9997 PyObject *arg3 = (PyObject *) 0 ;
9998 void *argp1 = 0 ;
9999 int res1 = 0 ;
10000 PyObject * obj0 = 0 ;
10001 PyObject * obj1 = 0 ;
10002 PyObject * obj2 = 0 ;
10003 char * kwnames[] = {
10004 (char *) "self",(char *) "self",(char *) "_class", NULL
10005 };
10006
10007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10009 if (!SWIG_IsOK(res1)) {
10010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10011 }
10012 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10013 arg2 = obj1;
10014 arg3 = obj2;
10015 {
10016 PyThreadState* __tstate = wxPyBeginAllowThreads();
10017 (arg1)->_setCallbackInfo(arg2,arg3);
10018 wxPyEndAllowThreads(__tstate);
10019 if (PyErr_Occurred()) SWIG_fail;
10020 }
10021 resultobj = SWIG_Py_Void();
10022 return resultobj;
10023 fail:
10024 return NULL;
10025 }
10026
10027
10028 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10029 PyObject *resultobj = 0;
10030 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10031 wxString *arg2 = 0 ;
10032 bool result;
10033 void *argp1 = 0 ;
10034 int res1 = 0 ;
10035 bool temp2 = false ;
10036 PyObject * obj0 = 0 ;
10037 PyObject * obj1 = 0 ;
10038 char * kwnames[] = {
10039 (char *) "self",(char *) "location", NULL
10040 };
10041
10042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10044 if (!SWIG_IsOK(res1)) {
10045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10046 }
10047 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10048 {
10049 arg2 = wxString_in_helper(obj1);
10050 if (arg2 == NULL) SWIG_fail;
10051 temp2 = true;
10052 }
10053 {
10054 PyThreadState* __tstate = wxPyBeginAllowThreads();
10055 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10056 wxPyEndAllowThreads(__tstate);
10057 if (PyErr_Occurred()) SWIG_fail;
10058 }
10059 {
10060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10061 }
10062 {
10063 if (temp2)
10064 delete arg2;
10065 }
10066 return resultobj;
10067 fail:
10068 {
10069 if (temp2)
10070 delete arg2;
10071 }
10072 return NULL;
10073 }
10074
10075
10076 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10077 PyObject *resultobj = 0;
10078 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10079 wxFileSystem *arg2 = 0 ;
10080 wxString *arg3 = 0 ;
10081 wxFSFile *result = 0 ;
10082 void *argp1 = 0 ;
10083 int res1 = 0 ;
10084 void *argp2 = 0 ;
10085 int res2 = 0 ;
10086 bool temp3 = false ;
10087 PyObject * obj0 = 0 ;
10088 PyObject * obj1 = 0 ;
10089 PyObject * obj2 = 0 ;
10090 char * kwnames[] = {
10091 (char *) "self",(char *) "fs",(char *) "location", NULL
10092 };
10093
10094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10096 if (!SWIG_IsOK(res1)) {
10097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10098 }
10099 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10100 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10101 if (!SWIG_IsOK(res2)) {
10102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10103 }
10104 if (!argp2) {
10105 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10106 }
10107 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10108 {
10109 arg3 = wxString_in_helper(obj2);
10110 if (arg3 == NULL) SWIG_fail;
10111 temp3 = true;
10112 }
10113 {
10114 PyThreadState* __tstate = wxPyBeginAllowThreads();
10115 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10116 wxPyEndAllowThreads(__tstate);
10117 if (PyErr_Occurred()) SWIG_fail;
10118 }
10119 {
10120 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10121 }
10122 {
10123 if (temp3)
10124 delete arg3;
10125 }
10126 return resultobj;
10127 fail:
10128 {
10129 if (temp3)
10130 delete arg3;
10131 }
10132 return NULL;
10133 }
10134
10135
10136 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10137 PyObject *resultobj = 0;
10138 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10139 wxString *arg2 = 0 ;
10140 int arg3 = (int) 0 ;
10141 wxString result;
10142 void *argp1 = 0 ;
10143 int res1 = 0 ;
10144 bool temp2 = false ;
10145 int val3 ;
10146 int ecode3 = 0 ;
10147 PyObject * obj0 = 0 ;
10148 PyObject * obj1 = 0 ;
10149 PyObject * obj2 = 0 ;
10150 char * kwnames[] = {
10151 (char *) "self",(char *) "spec",(char *) "flags", NULL
10152 };
10153
10154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10156 if (!SWIG_IsOK(res1)) {
10157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10158 }
10159 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10160 {
10161 arg2 = wxString_in_helper(obj1);
10162 if (arg2 == NULL) SWIG_fail;
10163 temp2 = true;
10164 }
10165 if (obj2) {
10166 ecode3 = SWIG_AsVal_int(obj2, &val3);
10167 if (!SWIG_IsOK(ecode3)) {
10168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10169 }
10170 arg3 = static_cast< int >(val3);
10171 }
10172 {
10173 PyThreadState* __tstate = wxPyBeginAllowThreads();
10174 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10175 wxPyEndAllowThreads(__tstate);
10176 if (PyErr_Occurred()) SWIG_fail;
10177 }
10178 {
10179 #if wxUSE_UNICODE
10180 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10181 #else
10182 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10183 #endif
10184 }
10185 {
10186 if (temp2)
10187 delete arg2;
10188 }
10189 return resultobj;
10190 fail:
10191 {
10192 if (temp2)
10193 delete arg2;
10194 }
10195 return NULL;
10196 }
10197
10198
10199 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10200 PyObject *resultobj = 0;
10201 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10202 wxString result;
10203 void *argp1 = 0 ;
10204 int res1 = 0 ;
10205 PyObject *swig_obj[1] ;
10206
10207 if (!args) SWIG_fail;
10208 swig_obj[0] = args;
10209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10210 if (!SWIG_IsOK(res1)) {
10211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10212 }
10213 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10214 {
10215 PyThreadState* __tstate = wxPyBeginAllowThreads();
10216 result = (arg1)->FindNext();
10217 wxPyEndAllowThreads(__tstate);
10218 if (PyErr_Occurred()) SWIG_fail;
10219 }
10220 {
10221 #if wxUSE_UNICODE
10222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10223 #else
10224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10225 #endif
10226 }
10227 return resultobj;
10228 fail:
10229 return NULL;
10230 }
10231
10232
10233 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10234 PyObject *resultobj = 0;
10235 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10236 wxString *arg2 = 0 ;
10237 wxString result;
10238 void *argp1 = 0 ;
10239 int res1 = 0 ;
10240 bool temp2 = false ;
10241 PyObject * obj0 = 0 ;
10242 PyObject * obj1 = 0 ;
10243 char * kwnames[] = {
10244 (char *) "self",(char *) "location", NULL
10245 };
10246
10247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10249 if (!SWIG_IsOK(res1)) {
10250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10251 }
10252 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10253 {
10254 arg2 = wxString_in_helper(obj1);
10255 if (arg2 == NULL) SWIG_fail;
10256 temp2 = true;
10257 }
10258 {
10259 PyThreadState* __tstate = wxPyBeginAllowThreads();
10260 result = (arg1)->GetProtocol((wxString const &)*arg2);
10261 wxPyEndAllowThreads(__tstate);
10262 if (PyErr_Occurred()) SWIG_fail;
10263 }
10264 {
10265 #if wxUSE_UNICODE
10266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10267 #else
10268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10269 #endif
10270 }
10271 {
10272 if (temp2)
10273 delete arg2;
10274 }
10275 return resultobj;
10276 fail:
10277 {
10278 if (temp2)
10279 delete arg2;
10280 }
10281 return NULL;
10282 }
10283
10284
10285 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10286 PyObject *resultobj = 0;
10287 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10288 wxString *arg2 = 0 ;
10289 wxString result;
10290 void *argp1 = 0 ;
10291 int res1 = 0 ;
10292 bool temp2 = false ;
10293 PyObject * obj0 = 0 ;
10294 PyObject * obj1 = 0 ;
10295 char * kwnames[] = {
10296 (char *) "self",(char *) "location", NULL
10297 };
10298
10299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10301 if (!SWIG_IsOK(res1)) {
10302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10303 }
10304 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10305 {
10306 arg2 = wxString_in_helper(obj1);
10307 if (arg2 == NULL) SWIG_fail;
10308 temp2 = true;
10309 }
10310 {
10311 PyThreadState* __tstate = wxPyBeginAllowThreads();
10312 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10313 wxPyEndAllowThreads(__tstate);
10314 if (PyErr_Occurred()) SWIG_fail;
10315 }
10316 {
10317 #if wxUSE_UNICODE
10318 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10319 #else
10320 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10321 #endif
10322 }
10323 {
10324 if (temp2)
10325 delete arg2;
10326 }
10327 return resultobj;
10328 fail:
10329 {
10330 if (temp2)
10331 delete arg2;
10332 }
10333 return NULL;
10334 }
10335
10336
10337 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10338 PyObject *resultobj = 0;
10339 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10340 wxString *arg2 = 0 ;
10341 wxString result;
10342 void *argp1 = 0 ;
10343 int res1 = 0 ;
10344 bool temp2 = false ;
10345 PyObject * obj0 = 0 ;
10346 PyObject * obj1 = 0 ;
10347 char * kwnames[] = {
10348 (char *) "self",(char *) "location", NULL
10349 };
10350
10351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10353 if (!SWIG_IsOK(res1)) {
10354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10355 }
10356 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10357 {
10358 arg2 = wxString_in_helper(obj1);
10359 if (arg2 == NULL) SWIG_fail;
10360 temp2 = true;
10361 }
10362 {
10363 PyThreadState* __tstate = wxPyBeginAllowThreads();
10364 result = (arg1)->GetAnchor((wxString const &)*arg2);
10365 wxPyEndAllowThreads(__tstate);
10366 if (PyErr_Occurred()) SWIG_fail;
10367 }
10368 {
10369 #if wxUSE_UNICODE
10370 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10371 #else
10372 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10373 #endif
10374 }
10375 {
10376 if (temp2)
10377 delete arg2;
10378 }
10379 return resultobj;
10380 fail:
10381 {
10382 if (temp2)
10383 delete arg2;
10384 }
10385 return NULL;
10386 }
10387
10388
10389 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10390 PyObject *resultobj = 0;
10391 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10392 wxString *arg2 = 0 ;
10393 wxString result;
10394 void *argp1 = 0 ;
10395 int res1 = 0 ;
10396 bool temp2 = false ;
10397 PyObject * obj0 = 0 ;
10398 PyObject * obj1 = 0 ;
10399 char * kwnames[] = {
10400 (char *) "self",(char *) "location", NULL
10401 };
10402
10403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10405 if (!SWIG_IsOK(res1)) {
10406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10407 }
10408 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10409 {
10410 arg2 = wxString_in_helper(obj1);
10411 if (arg2 == NULL) SWIG_fail;
10412 temp2 = true;
10413 }
10414 {
10415 PyThreadState* __tstate = wxPyBeginAllowThreads();
10416 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10417 wxPyEndAllowThreads(__tstate);
10418 if (PyErr_Occurred()) SWIG_fail;
10419 }
10420 {
10421 #if wxUSE_UNICODE
10422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10423 #else
10424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10425 #endif
10426 }
10427 {
10428 if (temp2)
10429 delete arg2;
10430 }
10431 return resultobj;
10432 fail:
10433 {
10434 if (temp2)
10435 delete arg2;
10436 }
10437 return NULL;
10438 }
10439
10440
10441 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10442 PyObject *resultobj = 0;
10443 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10444 wxString *arg2 = 0 ;
10445 wxString result;
10446 void *argp1 = 0 ;
10447 int res1 = 0 ;
10448 bool temp2 = false ;
10449 PyObject * obj0 = 0 ;
10450 PyObject * obj1 = 0 ;
10451 char * kwnames[] = {
10452 (char *) "self",(char *) "location", NULL
10453 };
10454
10455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10457 if (!SWIG_IsOK(res1)) {
10458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10459 }
10460 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10461 {
10462 arg2 = wxString_in_helper(obj1);
10463 if (arg2 == NULL) SWIG_fail;
10464 temp2 = true;
10465 }
10466 {
10467 PyThreadState* __tstate = wxPyBeginAllowThreads();
10468 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10469 wxPyEndAllowThreads(__tstate);
10470 if (PyErr_Occurred()) SWIG_fail;
10471 }
10472 {
10473 #if wxUSE_UNICODE
10474 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10475 #else
10476 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10477 #endif
10478 }
10479 {
10480 if (temp2)
10481 delete arg2;
10482 }
10483 return resultobj;
10484 fail:
10485 {
10486 if (temp2)
10487 delete arg2;
10488 }
10489 return NULL;
10490 }
10491
10492
10493 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10494 PyObject *obj;
10495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10496 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10497 return SWIG_Py_Void();
10498 }
10499
10500 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10501 return SWIG_Python_InitShadowInstance(args);
10502 }
10503
10504 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10505 PyObject *resultobj = 0;
10506 wxFileSystem *result = 0 ;
10507
10508 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10509 {
10510 PyThreadState* __tstate = wxPyBeginAllowThreads();
10511 result = (wxFileSystem *)new wxFileSystem();
10512 wxPyEndAllowThreads(__tstate);
10513 if (PyErr_Occurred()) SWIG_fail;
10514 }
10515 {
10516 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10517 }
10518 return resultobj;
10519 fail:
10520 return NULL;
10521 }
10522
10523
10524 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10525 PyObject *resultobj = 0;
10526 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10527 void *argp1 = 0 ;
10528 int res1 = 0 ;
10529 PyObject *swig_obj[1] ;
10530
10531 if (!args) SWIG_fail;
10532 swig_obj[0] = args;
10533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10534 if (!SWIG_IsOK(res1)) {
10535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10536 }
10537 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10538 {
10539 PyThreadState* __tstate = wxPyBeginAllowThreads();
10540 delete arg1;
10541
10542 wxPyEndAllowThreads(__tstate);
10543 if (PyErr_Occurred()) SWIG_fail;
10544 }
10545 resultobj = SWIG_Py_Void();
10546 return resultobj;
10547 fail:
10548 return NULL;
10549 }
10550
10551
10552 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10553 PyObject *resultobj = 0;
10554 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10555 wxString *arg2 = 0 ;
10556 bool arg3 = (bool) false ;
10557 void *argp1 = 0 ;
10558 int res1 = 0 ;
10559 bool temp2 = false ;
10560 bool val3 ;
10561 int ecode3 = 0 ;
10562 PyObject * obj0 = 0 ;
10563 PyObject * obj1 = 0 ;
10564 PyObject * obj2 = 0 ;
10565 char * kwnames[] = {
10566 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10567 };
10568
10569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10571 if (!SWIG_IsOK(res1)) {
10572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10573 }
10574 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10575 {
10576 arg2 = wxString_in_helper(obj1);
10577 if (arg2 == NULL) SWIG_fail;
10578 temp2 = true;
10579 }
10580 if (obj2) {
10581 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10582 if (!SWIG_IsOK(ecode3)) {
10583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10584 }
10585 arg3 = static_cast< bool >(val3);
10586 }
10587 {
10588 PyThreadState* __tstate = wxPyBeginAllowThreads();
10589 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10590 wxPyEndAllowThreads(__tstate);
10591 if (PyErr_Occurred()) SWIG_fail;
10592 }
10593 resultobj = SWIG_Py_Void();
10594 {
10595 if (temp2)
10596 delete arg2;
10597 }
10598 return resultobj;
10599 fail:
10600 {
10601 if (temp2)
10602 delete arg2;
10603 }
10604 return NULL;
10605 }
10606
10607
10608 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10609 PyObject *resultobj = 0;
10610 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10611 wxString result;
10612 void *argp1 = 0 ;
10613 int res1 = 0 ;
10614 PyObject *swig_obj[1] ;
10615
10616 if (!args) SWIG_fail;
10617 swig_obj[0] = args;
10618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10619 if (!SWIG_IsOK(res1)) {
10620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10621 }
10622 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10623 {
10624 PyThreadState* __tstate = wxPyBeginAllowThreads();
10625 result = (arg1)->GetPath();
10626 wxPyEndAllowThreads(__tstate);
10627 if (PyErr_Occurred()) SWIG_fail;
10628 }
10629 {
10630 #if wxUSE_UNICODE
10631 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10632 #else
10633 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10634 #endif
10635 }
10636 return resultobj;
10637 fail:
10638 return NULL;
10639 }
10640
10641
10642 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10643 PyObject *resultobj = 0;
10644 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10645 wxString *arg2 = 0 ;
10646 wxFSFile *result = 0 ;
10647 void *argp1 = 0 ;
10648 int res1 = 0 ;
10649 bool temp2 = false ;
10650 PyObject * obj0 = 0 ;
10651 PyObject * obj1 = 0 ;
10652 char * kwnames[] = {
10653 (char *) "self",(char *) "location", NULL
10654 };
10655
10656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10658 if (!SWIG_IsOK(res1)) {
10659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10660 }
10661 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10662 {
10663 arg2 = wxString_in_helper(obj1);
10664 if (arg2 == NULL) SWIG_fail;
10665 temp2 = true;
10666 }
10667 {
10668 PyThreadState* __tstate = wxPyBeginAllowThreads();
10669 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10670 wxPyEndAllowThreads(__tstate);
10671 if (PyErr_Occurred()) SWIG_fail;
10672 }
10673 {
10674 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10675 }
10676 {
10677 if (temp2)
10678 delete arg2;
10679 }
10680 return resultobj;
10681 fail:
10682 {
10683 if (temp2)
10684 delete arg2;
10685 }
10686 return NULL;
10687 }
10688
10689
10690 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10691 PyObject *resultobj = 0;
10692 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10693 wxString *arg2 = 0 ;
10694 int arg3 = (int) 0 ;
10695 wxString result;
10696 void *argp1 = 0 ;
10697 int res1 = 0 ;
10698 bool temp2 = false ;
10699 int val3 ;
10700 int ecode3 = 0 ;
10701 PyObject * obj0 = 0 ;
10702 PyObject * obj1 = 0 ;
10703 PyObject * obj2 = 0 ;
10704 char * kwnames[] = {
10705 (char *) "self",(char *) "spec",(char *) "flags", NULL
10706 };
10707
10708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10710 if (!SWIG_IsOK(res1)) {
10711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10712 }
10713 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10714 {
10715 arg2 = wxString_in_helper(obj1);
10716 if (arg2 == NULL) SWIG_fail;
10717 temp2 = true;
10718 }
10719 if (obj2) {
10720 ecode3 = SWIG_AsVal_int(obj2, &val3);
10721 if (!SWIG_IsOK(ecode3)) {
10722 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10723 }
10724 arg3 = static_cast< int >(val3);
10725 }
10726 {
10727 PyThreadState* __tstate = wxPyBeginAllowThreads();
10728 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10729 wxPyEndAllowThreads(__tstate);
10730 if (PyErr_Occurred()) SWIG_fail;
10731 }
10732 {
10733 #if wxUSE_UNICODE
10734 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10735 #else
10736 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10737 #endif
10738 }
10739 {
10740 if (temp2)
10741 delete arg2;
10742 }
10743 return resultobj;
10744 fail:
10745 {
10746 if (temp2)
10747 delete arg2;
10748 }
10749 return NULL;
10750 }
10751
10752
10753 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10754 PyObject *resultobj = 0;
10755 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10756 wxString result;
10757 void *argp1 = 0 ;
10758 int res1 = 0 ;
10759 PyObject *swig_obj[1] ;
10760
10761 if (!args) SWIG_fail;
10762 swig_obj[0] = args;
10763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10764 if (!SWIG_IsOK(res1)) {
10765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10766 }
10767 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10768 {
10769 PyThreadState* __tstate = wxPyBeginAllowThreads();
10770 result = (arg1)->FindNext();
10771 wxPyEndAllowThreads(__tstate);
10772 if (PyErr_Occurred()) SWIG_fail;
10773 }
10774 {
10775 #if wxUSE_UNICODE
10776 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10777 #else
10778 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10779 #endif
10780 }
10781 return resultobj;
10782 fail:
10783 return NULL;
10784 }
10785
10786
10787 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10788 PyObject *resultobj = 0;
10789 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10790 int res1 = 0 ;
10791 PyObject * obj0 = 0 ;
10792 char * kwnames[] = {
10793 (char *) "handler", NULL
10794 };
10795
10796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10797 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10798 if (!SWIG_IsOK(res1)) {
10799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10800 }
10801 {
10802 PyThreadState* __tstate = wxPyBeginAllowThreads();
10803 wxFileSystem::AddHandler(arg1);
10804 wxPyEndAllowThreads(__tstate);
10805 if (PyErr_Occurred()) SWIG_fail;
10806 }
10807 resultobj = SWIG_Py_Void();
10808 return resultobj;
10809 fail:
10810 return NULL;
10811 }
10812
10813
10814 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10815 PyObject *resultobj = 0;
10816
10817 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10818 {
10819 PyThreadState* __tstate = wxPyBeginAllowThreads();
10820 wxFileSystem::CleanUpHandlers();
10821 wxPyEndAllowThreads(__tstate);
10822 if (PyErr_Occurred()) SWIG_fail;
10823 }
10824 resultobj = SWIG_Py_Void();
10825 return resultobj;
10826 fail:
10827 return NULL;
10828 }
10829
10830
10831 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10832 PyObject *resultobj = 0;
10833 wxString *arg1 = 0 ;
10834 wxString result;
10835 bool temp1 = false ;
10836 PyObject * obj0 = 0 ;
10837 char * kwnames[] = {
10838 (char *) "filename", NULL
10839 };
10840
10841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10842 {
10843 arg1 = wxString_in_helper(obj0);
10844 if (arg1 == NULL) SWIG_fail;
10845 temp1 = true;
10846 }
10847 {
10848 PyThreadState* __tstate = wxPyBeginAllowThreads();
10849 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10850 wxPyEndAllowThreads(__tstate);
10851 if (PyErr_Occurred()) SWIG_fail;
10852 }
10853 {
10854 #if wxUSE_UNICODE
10855 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10856 #else
10857 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10858 #endif
10859 }
10860 {
10861 if (temp1)
10862 delete arg1;
10863 }
10864 return resultobj;
10865 fail:
10866 {
10867 if (temp1)
10868 delete arg1;
10869 }
10870 return NULL;
10871 }
10872
10873
10874 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10875 PyObject *resultobj = 0;
10876 wxString *arg1 = 0 ;
10877 wxString result;
10878 bool temp1 = false ;
10879 PyObject * obj0 = 0 ;
10880 char * kwnames[] = {
10881 (char *) "url", NULL
10882 };
10883
10884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10885 {
10886 arg1 = wxString_in_helper(obj0);
10887 if (arg1 == NULL) SWIG_fail;
10888 temp1 = true;
10889 }
10890 {
10891 PyThreadState* __tstate = wxPyBeginAllowThreads();
10892 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10893 wxPyEndAllowThreads(__tstate);
10894 if (PyErr_Occurred()) SWIG_fail;
10895 }
10896 {
10897 #if wxUSE_UNICODE
10898 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10899 #else
10900 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10901 #endif
10902 }
10903 {
10904 if (temp1)
10905 delete arg1;
10906 }
10907 return resultobj;
10908 fail:
10909 {
10910 if (temp1)
10911 delete arg1;
10912 }
10913 return NULL;
10914 }
10915
10916
10917 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10918 PyObject *obj;
10919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10920 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10921 return SWIG_Py_Void();
10922 }
10923
10924 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10925 return SWIG_Python_InitShadowInstance(args);
10926 }
10927
10928 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10929 PyObject *resultobj = 0;
10930 wxInternetFSHandler *result = 0 ;
10931
10932 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10933 {
10934 PyThreadState* __tstate = wxPyBeginAllowThreads();
10935 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10936 wxPyEndAllowThreads(__tstate);
10937 if (PyErr_Occurred()) SWIG_fail;
10938 }
10939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10947 PyObject *resultobj = 0;
10948 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10949 wxString *arg2 = 0 ;
10950 bool result;
10951 void *argp1 = 0 ;
10952 int res1 = 0 ;
10953 bool temp2 = false ;
10954 PyObject * obj0 = 0 ;
10955 PyObject * obj1 = 0 ;
10956 char * kwnames[] = {
10957 (char *) "self",(char *) "location", NULL
10958 };
10959
10960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10962 if (!SWIG_IsOK(res1)) {
10963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10964 }
10965 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10966 {
10967 arg2 = wxString_in_helper(obj1);
10968 if (arg2 == NULL) SWIG_fail;
10969 temp2 = true;
10970 }
10971 {
10972 PyThreadState* __tstate = wxPyBeginAllowThreads();
10973 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10974 wxPyEndAllowThreads(__tstate);
10975 if (PyErr_Occurred()) SWIG_fail;
10976 }
10977 {
10978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10979 }
10980 {
10981 if (temp2)
10982 delete arg2;
10983 }
10984 return resultobj;
10985 fail:
10986 {
10987 if (temp2)
10988 delete arg2;
10989 }
10990 return NULL;
10991 }
10992
10993
10994 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10995 PyObject *resultobj = 0;
10996 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10997 wxFileSystem *arg2 = 0 ;
10998 wxString *arg3 = 0 ;
10999 wxFSFile *result = 0 ;
11000 void *argp1 = 0 ;
11001 int res1 = 0 ;
11002 void *argp2 = 0 ;
11003 int res2 = 0 ;
11004 bool temp3 = false ;
11005 PyObject * obj0 = 0 ;
11006 PyObject * obj1 = 0 ;
11007 PyObject * obj2 = 0 ;
11008 char * kwnames[] = {
11009 (char *) "self",(char *) "fs",(char *) "location", NULL
11010 };
11011
11012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11014 if (!SWIG_IsOK(res1)) {
11015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11016 }
11017 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11018 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11019 if (!SWIG_IsOK(res2)) {
11020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11021 }
11022 if (!argp2) {
11023 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11024 }
11025 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11026 {
11027 arg3 = wxString_in_helper(obj2);
11028 if (arg3 == NULL) SWIG_fail;
11029 temp3 = true;
11030 }
11031 {
11032 PyThreadState* __tstate = wxPyBeginAllowThreads();
11033 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11034 wxPyEndAllowThreads(__tstate);
11035 if (PyErr_Occurred()) SWIG_fail;
11036 }
11037 {
11038 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11039 }
11040 {
11041 if (temp3)
11042 delete arg3;
11043 }
11044 return resultobj;
11045 fail:
11046 {
11047 if (temp3)
11048 delete arg3;
11049 }
11050 return NULL;
11051 }
11052
11053
11054 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11055 PyObject *obj;
11056 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11057 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11058 return SWIG_Py_Void();
11059 }
11060
11061 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11062 return SWIG_Python_InitShadowInstance(args);
11063 }
11064
11065 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11066 PyObject *resultobj = 0;
11067 wxZipFSHandler *result = 0 ;
11068
11069 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11070 {
11071 PyThreadState* __tstate = wxPyBeginAllowThreads();
11072 result = (wxZipFSHandler *)new wxZipFSHandler();
11073 wxPyEndAllowThreads(__tstate);
11074 if (PyErr_Occurred()) SWIG_fail;
11075 }
11076 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11077 return resultobj;
11078 fail:
11079 return NULL;
11080 }
11081
11082
11083 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11084 PyObject *resultobj = 0;
11085 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11086 wxString *arg2 = 0 ;
11087 bool result;
11088 void *argp1 = 0 ;
11089 int res1 = 0 ;
11090 bool temp2 = false ;
11091 PyObject * obj0 = 0 ;
11092 PyObject * obj1 = 0 ;
11093 char * kwnames[] = {
11094 (char *) "self",(char *) "location", NULL
11095 };
11096
11097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11099 if (!SWIG_IsOK(res1)) {
11100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11101 }
11102 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11103 {
11104 arg2 = wxString_in_helper(obj1);
11105 if (arg2 == NULL) SWIG_fail;
11106 temp2 = true;
11107 }
11108 {
11109 PyThreadState* __tstate = wxPyBeginAllowThreads();
11110 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11111 wxPyEndAllowThreads(__tstate);
11112 if (PyErr_Occurred()) SWIG_fail;
11113 }
11114 {
11115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11116 }
11117 {
11118 if (temp2)
11119 delete arg2;
11120 }
11121 return resultobj;
11122 fail:
11123 {
11124 if (temp2)
11125 delete arg2;
11126 }
11127 return NULL;
11128 }
11129
11130
11131 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11132 PyObject *resultobj = 0;
11133 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11134 wxFileSystem *arg2 = 0 ;
11135 wxString *arg3 = 0 ;
11136 wxFSFile *result = 0 ;
11137 void *argp1 = 0 ;
11138 int res1 = 0 ;
11139 void *argp2 = 0 ;
11140 int res2 = 0 ;
11141 bool temp3 = false ;
11142 PyObject * obj0 = 0 ;
11143 PyObject * obj1 = 0 ;
11144 PyObject * obj2 = 0 ;
11145 char * kwnames[] = {
11146 (char *) "self",(char *) "fs",(char *) "location", NULL
11147 };
11148
11149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11151 if (!SWIG_IsOK(res1)) {
11152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11153 }
11154 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11155 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11156 if (!SWIG_IsOK(res2)) {
11157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11158 }
11159 if (!argp2) {
11160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11161 }
11162 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11163 {
11164 arg3 = wxString_in_helper(obj2);
11165 if (arg3 == NULL) SWIG_fail;
11166 temp3 = true;
11167 }
11168 {
11169 PyThreadState* __tstate = wxPyBeginAllowThreads();
11170 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11171 wxPyEndAllowThreads(__tstate);
11172 if (PyErr_Occurred()) SWIG_fail;
11173 }
11174 {
11175 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11176 }
11177 {
11178 if (temp3)
11179 delete arg3;
11180 }
11181 return resultobj;
11182 fail:
11183 {
11184 if (temp3)
11185 delete arg3;
11186 }
11187 return NULL;
11188 }
11189
11190
11191 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11192 PyObject *resultobj = 0;
11193 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11194 wxString *arg2 = 0 ;
11195 int arg3 = (int) 0 ;
11196 wxString result;
11197 void *argp1 = 0 ;
11198 int res1 = 0 ;
11199 bool temp2 = false ;
11200 int val3 ;
11201 int ecode3 = 0 ;
11202 PyObject * obj0 = 0 ;
11203 PyObject * obj1 = 0 ;
11204 PyObject * obj2 = 0 ;
11205 char * kwnames[] = {
11206 (char *) "self",(char *) "spec",(char *) "flags", NULL
11207 };
11208
11209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11211 if (!SWIG_IsOK(res1)) {
11212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11213 }
11214 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11215 {
11216 arg2 = wxString_in_helper(obj1);
11217 if (arg2 == NULL) SWIG_fail;
11218 temp2 = true;
11219 }
11220 if (obj2) {
11221 ecode3 = SWIG_AsVal_int(obj2, &val3);
11222 if (!SWIG_IsOK(ecode3)) {
11223 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11224 }
11225 arg3 = static_cast< int >(val3);
11226 }
11227 {
11228 PyThreadState* __tstate = wxPyBeginAllowThreads();
11229 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11230 wxPyEndAllowThreads(__tstate);
11231 if (PyErr_Occurred()) SWIG_fail;
11232 }
11233 {
11234 #if wxUSE_UNICODE
11235 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11236 #else
11237 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11238 #endif
11239 }
11240 {
11241 if (temp2)
11242 delete arg2;
11243 }
11244 return resultobj;
11245 fail:
11246 {
11247 if (temp2)
11248 delete arg2;
11249 }
11250 return NULL;
11251 }
11252
11253
11254 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11255 PyObject *resultobj = 0;
11256 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11257 wxString result;
11258 void *argp1 = 0 ;
11259 int res1 = 0 ;
11260 PyObject *swig_obj[1] ;
11261
11262 if (!args) SWIG_fail;
11263 swig_obj[0] = args;
11264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11265 if (!SWIG_IsOK(res1)) {
11266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11267 }
11268 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11269 {
11270 PyThreadState* __tstate = wxPyBeginAllowThreads();
11271 result = (arg1)->FindNext();
11272 wxPyEndAllowThreads(__tstate);
11273 if (PyErr_Occurred()) SWIG_fail;
11274 }
11275 {
11276 #if wxUSE_UNICODE
11277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11278 #else
11279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11280 #endif
11281 }
11282 return resultobj;
11283 fail:
11284 return NULL;
11285 }
11286
11287
11288 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11289 PyObject *obj;
11290 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11291 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11292 return SWIG_Py_Void();
11293 }
11294
11295 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11296 return SWIG_Python_InitShadowInstance(args);
11297 }
11298
11299 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11300 PyObject *resultobj = 0;
11301 wxString *arg1 = 0 ;
11302 wxImage *arg2 = 0 ;
11303 long arg3 ;
11304 bool temp1 = false ;
11305 void *argp2 = 0 ;
11306 int res2 = 0 ;
11307 long val3 ;
11308 int ecode3 = 0 ;
11309 PyObject * obj0 = 0 ;
11310 PyObject * obj1 = 0 ;
11311 PyObject * obj2 = 0 ;
11312 char * kwnames[] = {
11313 (char *) "filename",(char *) "image",(char *) "type", NULL
11314 };
11315
11316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11317 {
11318 arg1 = wxString_in_helper(obj0);
11319 if (arg1 == NULL) SWIG_fail;
11320 temp1 = true;
11321 }
11322 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11323 if (!SWIG_IsOK(res2)) {
11324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11325 }
11326 if (!argp2) {
11327 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11328 }
11329 arg2 = reinterpret_cast< wxImage * >(argp2);
11330 ecode3 = SWIG_AsVal_long(obj2, &val3);
11331 if (!SWIG_IsOK(ecode3)) {
11332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11333 }
11334 arg3 = static_cast< long >(val3);
11335 {
11336 PyThreadState* __tstate = wxPyBeginAllowThreads();
11337 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11338 wxPyEndAllowThreads(__tstate);
11339 if (PyErr_Occurred()) SWIG_fail;
11340 }
11341 resultobj = SWIG_Py_Void();
11342 {
11343 if (temp1)
11344 delete arg1;
11345 }
11346 return resultobj;
11347 fail:
11348 {
11349 if (temp1)
11350 delete arg1;
11351 }
11352 return NULL;
11353 }
11354
11355
11356 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11357 PyObject *resultobj = 0;
11358 wxString *arg1 = 0 ;
11359 wxBitmap *arg2 = 0 ;
11360 long arg3 ;
11361 bool temp1 = false ;
11362 void *argp2 = 0 ;
11363 int res2 = 0 ;
11364 long val3 ;
11365 int ecode3 = 0 ;
11366 PyObject * obj0 = 0 ;
11367 PyObject * obj1 = 0 ;
11368 PyObject * obj2 = 0 ;
11369 char * kwnames[] = {
11370 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11371 };
11372
11373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11374 {
11375 arg1 = wxString_in_helper(obj0);
11376 if (arg1 == NULL) SWIG_fail;
11377 temp1 = true;
11378 }
11379 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11380 if (!SWIG_IsOK(res2)) {
11381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11382 }
11383 if (!argp2) {
11384 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11385 }
11386 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11387 ecode3 = SWIG_AsVal_long(obj2, &val3);
11388 if (!SWIG_IsOK(ecode3)) {
11389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11390 }
11391 arg3 = static_cast< long >(val3);
11392 {
11393 PyThreadState* __tstate = wxPyBeginAllowThreads();
11394 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11395 wxPyEndAllowThreads(__tstate);
11396 if (PyErr_Occurred()) SWIG_fail;
11397 }
11398 resultobj = SWIG_Py_Void();
11399 {
11400 if (temp1)
11401 delete arg1;
11402 }
11403 return resultobj;
11404 fail:
11405 {
11406 if (temp1)
11407 delete arg1;
11408 }
11409 return NULL;
11410 }
11411
11412
11413 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11414 PyObject *resultobj = 0;
11415 wxString *arg1 = 0 ;
11416 PyObject *arg2 = (PyObject *) 0 ;
11417 bool temp1 = false ;
11418 PyObject * obj0 = 0 ;
11419 PyObject * obj1 = 0 ;
11420 char * kwnames[] = {
11421 (char *) "filename",(char *) "data", NULL
11422 };
11423
11424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11425 {
11426 arg1 = wxString_in_helper(obj0);
11427 if (arg1 == NULL) SWIG_fail;
11428 temp1 = true;
11429 }
11430 arg2 = obj1;
11431 {
11432 PyThreadState* __tstate = wxPyBeginAllowThreads();
11433 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11434 wxPyEndAllowThreads(__tstate);
11435 if (PyErr_Occurred()) SWIG_fail;
11436 }
11437 resultobj = SWIG_Py_Void();
11438 {
11439 if (temp1)
11440 delete arg1;
11441 }
11442 return resultobj;
11443 fail:
11444 {
11445 if (temp1)
11446 delete arg1;
11447 }
11448 return NULL;
11449 }
11450
11451
11452 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11453 PyObject *resultobj = 0;
11454 wxMemoryFSHandler *result = 0 ;
11455
11456 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11457 {
11458 PyThreadState* __tstate = wxPyBeginAllowThreads();
11459 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11460 wxPyEndAllowThreads(__tstate);
11461 if (PyErr_Occurred()) SWIG_fail;
11462 }
11463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11464 return resultobj;
11465 fail:
11466 return NULL;
11467 }
11468
11469
11470 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11471 PyObject *resultobj = 0;
11472 wxString *arg1 = 0 ;
11473 bool temp1 = false ;
11474 PyObject * obj0 = 0 ;
11475 char * kwnames[] = {
11476 (char *) "filename", NULL
11477 };
11478
11479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11480 {
11481 arg1 = wxString_in_helper(obj0);
11482 if (arg1 == NULL) SWIG_fail;
11483 temp1 = true;
11484 }
11485 {
11486 PyThreadState* __tstate = wxPyBeginAllowThreads();
11487 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11488 wxPyEndAllowThreads(__tstate);
11489 if (PyErr_Occurred()) SWIG_fail;
11490 }
11491 resultobj = SWIG_Py_Void();
11492 {
11493 if (temp1)
11494 delete arg1;
11495 }
11496 return resultobj;
11497 fail:
11498 {
11499 if (temp1)
11500 delete arg1;
11501 }
11502 return NULL;
11503 }
11504
11505
11506 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11507 PyObject *resultobj = 0;
11508 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11509 wxString *arg2 = 0 ;
11510 bool result;
11511 void *argp1 = 0 ;
11512 int res1 = 0 ;
11513 bool temp2 = false ;
11514 PyObject * obj0 = 0 ;
11515 PyObject * obj1 = 0 ;
11516 char * kwnames[] = {
11517 (char *) "self",(char *) "location", NULL
11518 };
11519
11520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11522 if (!SWIG_IsOK(res1)) {
11523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11524 }
11525 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11526 {
11527 arg2 = wxString_in_helper(obj1);
11528 if (arg2 == NULL) SWIG_fail;
11529 temp2 = true;
11530 }
11531 {
11532 PyThreadState* __tstate = wxPyBeginAllowThreads();
11533 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11534 wxPyEndAllowThreads(__tstate);
11535 if (PyErr_Occurred()) SWIG_fail;
11536 }
11537 {
11538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11539 }
11540 {
11541 if (temp2)
11542 delete arg2;
11543 }
11544 return resultobj;
11545 fail:
11546 {
11547 if (temp2)
11548 delete arg2;
11549 }
11550 return NULL;
11551 }
11552
11553
11554 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11555 PyObject *resultobj = 0;
11556 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11557 wxFileSystem *arg2 = 0 ;
11558 wxString *arg3 = 0 ;
11559 wxFSFile *result = 0 ;
11560 void *argp1 = 0 ;
11561 int res1 = 0 ;
11562 void *argp2 = 0 ;
11563 int res2 = 0 ;
11564 bool temp3 = false ;
11565 PyObject * obj0 = 0 ;
11566 PyObject * obj1 = 0 ;
11567 PyObject * obj2 = 0 ;
11568 char * kwnames[] = {
11569 (char *) "self",(char *) "fs",(char *) "location", NULL
11570 };
11571
11572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11574 if (!SWIG_IsOK(res1)) {
11575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11576 }
11577 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11578 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11579 if (!SWIG_IsOK(res2)) {
11580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11581 }
11582 if (!argp2) {
11583 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11584 }
11585 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11586 {
11587 arg3 = wxString_in_helper(obj2);
11588 if (arg3 == NULL) SWIG_fail;
11589 temp3 = true;
11590 }
11591 {
11592 PyThreadState* __tstate = wxPyBeginAllowThreads();
11593 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11594 wxPyEndAllowThreads(__tstate);
11595 if (PyErr_Occurred()) SWIG_fail;
11596 }
11597 {
11598 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11599 }
11600 {
11601 if (temp3)
11602 delete arg3;
11603 }
11604 return resultobj;
11605 fail:
11606 {
11607 if (temp3)
11608 delete arg3;
11609 }
11610 return NULL;
11611 }
11612
11613
11614 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11615 PyObject *resultobj = 0;
11616 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11617 wxString *arg2 = 0 ;
11618 int arg3 = (int) 0 ;
11619 wxString result;
11620 void *argp1 = 0 ;
11621 int res1 = 0 ;
11622 bool temp2 = false ;
11623 int val3 ;
11624 int ecode3 = 0 ;
11625 PyObject * obj0 = 0 ;
11626 PyObject * obj1 = 0 ;
11627 PyObject * obj2 = 0 ;
11628 char * kwnames[] = {
11629 (char *) "self",(char *) "spec",(char *) "flags", NULL
11630 };
11631
11632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11634 if (!SWIG_IsOK(res1)) {
11635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11636 }
11637 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11638 {
11639 arg2 = wxString_in_helper(obj1);
11640 if (arg2 == NULL) SWIG_fail;
11641 temp2 = true;
11642 }
11643 if (obj2) {
11644 ecode3 = SWIG_AsVal_int(obj2, &val3);
11645 if (!SWIG_IsOK(ecode3)) {
11646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11647 }
11648 arg3 = static_cast< int >(val3);
11649 }
11650 {
11651 PyThreadState* __tstate = wxPyBeginAllowThreads();
11652 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11653 wxPyEndAllowThreads(__tstate);
11654 if (PyErr_Occurred()) SWIG_fail;
11655 }
11656 {
11657 #if wxUSE_UNICODE
11658 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11659 #else
11660 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11661 #endif
11662 }
11663 {
11664 if (temp2)
11665 delete arg2;
11666 }
11667 return resultobj;
11668 fail:
11669 {
11670 if (temp2)
11671 delete arg2;
11672 }
11673 return NULL;
11674 }
11675
11676
11677 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11678 PyObject *resultobj = 0;
11679 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11680 wxString result;
11681 void *argp1 = 0 ;
11682 int res1 = 0 ;
11683 PyObject *swig_obj[1] ;
11684
11685 if (!args) SWIG_fail;
11686 swig_obj[0] = args;
11687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11688 if (!SWIG_IsOK(res1)) {
11689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11690 }
11691 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11692 {
11693 PyThreadState* __tstate = wxPyBeginAllowThreads();
11694 result = (arg1)->FindNext();
11695 wxPyEndAllowThreads(__tstate);
11696 if (PyErr_Occurred()) SWIG_fail;
11697 }
11698 {
11699 #if wxUSE_UNICODE
11700 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11701 #else
11702 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11703 #endif
11704 }
11705 return resultobj;
11706 fail:
11707 return NULL;
11708 }
11709
11710
11711 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11712 PyObject *obj;
11713 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11714 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11715 return SWIG_Py_Void();
11716 }
11717
11718 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11719 return SWIG_Python_InitShadowInstance(args);
11720 }
11721
11722 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11723 PyObject *resultobj = 0;
11724 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11725 wxString result;
11726 void *argp1 = 0 ;
11727 int res1 = 0 ;
11728 PyObject *swig_obj[1] ;
11729
11730 if (!args) SWIG_fail;
11731 swig_obj[0] = args;
11732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11733 if (!SWIG_IsOK(res1)) {
11734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11735 }
11736 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11737 {
11738 PyThreadState* __tstate = wxPyBeginAllowThreads();
11739 result = (arg1)->GetName();
11740 wxPyEndAllowThreads(__tstate);
11741 if (PyErr_Occurred()) SWIG_fail;
11742 }
11743 {
11744 #if wxUSE_UNICODE
11745 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11746 #else
11747 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11748 #endif
11749 }
11750 return resultobj;
11751 fail:
11752 return NULL;
11753 }
11754
11755
11756 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11757 PyObject *resultobj = 0;
11758 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11759 wxString result;
11760 void *argp1 = 0 ;
11761 int res1 = 0 ;
11762 PyObject *swig_obj[1] ;
11763
11764 if (!args) SWIG_fail;
11765 swig_obj[0] = args;
11766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11767 if (!SWIG_IsOK(res1)) {
11768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11769 }
11770 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11771 {
11772 PyThreadState* __tstate = wxPyBeginAllowThreads();
11773 result = (arg1)->GetExtension();
11774 wxPyEndAllowThreads(__tstate);
11775 if (PyErr_Occurred()) SWIG_fail;
11776 }
11777 {
11778 #if wxUSE_UNICODE
11779 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11780 #else
11781 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11782 #endif
11783 }
11784 return resultobj;
11785 fail:
11786 return NULL;
11787 }
11788
11789
11790 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11791 PyObject *resultobj = 0;
11792 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11793 long result;
11794 void *argp1 = 0 ;
11795 int res1 = 0 ;
11796 PyObject *swig_obj[1] ;
11797
11798 if (!args) SWIG_fail;
11799 swig_obj[0] = args;
11800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11801 if (!SWIG_IsOK(res1)) {
11802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11803 }
11804 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11805 {
11806 PyThreadState* __tstate = wxPyBeginAllowThreads();
11807 result = (long)(arg1)->GetType();
11808 wxPyEndAllowThreads(__tstate);
11809 if (PyErr_Occurred()) SWIG_fail;
11810 }
11811 resultobj = SWIG_From_long(static_cast< long >(result));
11812 return resultobj;
11813 fail:
11814 return NULL;
11815 }
11816
11817
11818 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11819 PyObject *resultobj = 0;
11820 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11821 wxString result;
11822 void *argp1 = 0 ;
11823 int res1 = 0 ;
11824 PyObject *swig_obj[1] ;
11825
11826 if (!args) SWIG_fail;
11827 swig_obj[0] = args;
11828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11829 if (!SWIG_IsOK(res1)) {
11830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11831 }
11832 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11833 {
11834 PyThreadState* __tstate = wxPyBeginAllowThreads();
11835 result = (arg1)->GetMimeType();
11836 wxPyEndAllowThreads(__tstate);
11837 if (PyErr_Occurred()) SWIG_fail;
11838 }
11839 {
11840 #if wxUSE_UNICODE
11841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11842 #else
11843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11844 #endif
11845 }
11846 return resultobj;
11847 fail:
11848 return NULL;
11849 }
11850
11851
11852 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11853 PyObject *resultobj = 0;
11854 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11855 wxString *arg2 = 0 ;
11856 bool result;
11857 void *argp1 = 0 ;
11858 int res1 = 0 ;
11859 bool temp2 = false ;
11860 PyObject * obj0 = 0 ;
11861 PyObject * obj1 = 0 ;
11862 char * kwnames[] = {
11863 (char *) "self",(char *) "name", NULL
11864 };
11865
11866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11868 if (!SWIG_IsOK(res1)) {
11869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11870 }
11871 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11872 {
11873 arg2 = wxString_in_helper(obj1);
11874 if (arg2 == NULL) SWIG_fail;
11875 temp2 = true;
11876 }
11877 {
11878 PyThreadState* __tstate = wxPyBeginAllowThreads();
11879 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11880 wxPyEndAllowThreads(__tstate);
11881 if (PyErr_Occurred()) SWIG_fail;
11882 }
11883 {
11884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11885 }
11886 {
11887 if (temp2)
11888 delete arg2;
11889 }
11890 return resultobj;
11891 fail:
11892 {
11893 if (temp2)
11894 delete arg2;
11895 }
11896 return NULL;
11897 }
11898
11899
11900 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11901 PyObject *resultobj = 0;
11902 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11903 wxInputStream *arg2 = 0 ;
11904 bool result;
11905 void *argp1 = 0 ;
11906 int res1 = 0 ;
11907 wxPyInputStream *temp2 ;
11908 bool created2 ;
11909 PyObject * obj0 = 0 ;
11910 PyObject * obj1 = 0 ;
11911 char * kwnames[] = {
11912 (char *) "self",(char *) "stream", NULL
11913 };
11914
11915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11917 if (!SWIG_IsOK(res1)) {
11918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11919 }
11920 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11921 {
11922 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11923 arg2 = temp2->m_wxis;
11924 created2 = false;
11925 } else {
11926 PyErr_Clear(); // clear the failure of the wxPyConvert above
11927 arg2 = wxPyCBInputStream_create(obj1, false);
11928 if (arg2 == NULL) {
11929 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11930 SWIG_fail;
11931 }
11932 created2 = true;
11933 }
11934 }
11935 {
11936 PyThreadState* __tstate = wxPyBeginAllowThreads();
11937 result = (bool)(arg1)->CanRead(*arg2);
11938 wxPyEndAllowThreads(__tstate);
11939 if (PyErr_Occurred()) SWIG_fail;
11940 }
11941 {
11942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11943 }
11944 {
11945 if (created2) delete arg2;
11946 }
11947 return resultobj;
11948 fail:
11949 {
11950 if (created2) delete arg2;
11951 }
11952 return NULL;
11953 }
11954
11955
11956 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11957 PyObject *resultobj = 0;
11958 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11959 wxString *arg2 = 0 ;
11960 void *argp1 = 0 ;
11961 int res1 = 0 ;
11962 bool temp2 = false ;
11963 PyObject * obj0 = 0 ;
11964 PyObject * obj1 = 0 ;
11965 char * kwnames[] = {
11966 (char *) "self",(char *) "name", NULL
11967 };
11968
11969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11971 if (!SWIG_IsOK(res1)) {
11972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11973 }
11974 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11975 {
11976 arg2 = wxString_in_helper(obj1);
11977 if (arg2 == NULL) SWIG_fail;
11978 temp2 = true;
11979 }
11980 {
11981 PyThreadState* __tstate = wxPyBeginAllowThreads();
11982 (arg1)->SetName((wxString const &)*arg2);
11983 wxPyEndAllowThreads(__tstate);
11984 if (PyErr_Occurred()) SWIG_fail;
11985 }
11986 resultobj = SWIG_Py_Void();
11987 {
11988 if (temp2)
11989 delete arg2;
11990 }
11991 return resultobj;
11992 fail:
11993 {
11994 if (temp2)
11995 delete arg2;
11996 }
11997 return NULL;
11998 }
11999
12000
12001 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12002 PyObject *resultobj = 0;
12003 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12004 wxString *arg2 = 0 ;
12005 void *argp1 = 0 ;
12006 int res1 = 0 ;
12007 bool temp2 = false ;
12008 PyObject * obj0 = 0 ;
12009 PyObject * obj1 = 0 ;
12010 char * kwnames[] = {
12011 (char *) "self",(char *) "extension", NULL
12012 };
12013
12014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12016 if (!SWIG_IsOK(res1)) {
12017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12018 }
12019 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12020 {
12021 arg2 = wxString_in_helper(obj1);
12022 if (arg2 == NULL) SWIG_fail;
12023 temp2 = true;
12024 }
12025 {
12026 PyThreadState* __tstate = wxPyBeginAllowThreads();
12027 (arg1)->SetExtension((wxString const &)*arg2);
12028 wxPyEndAllowThreads(__tstate);
12029 if (PyErr_Occurred()) SWIG_fail;
12030 }
12031 resultobj = SWIG_Py_Void();
12032 {
12033 if (temp2)
12034 delete arg2;
12035 }
12036 return resultobj;
12037 fail:
12038 {
12039 if (temp2)
12040 delete arg2;
12041 }
12042 return NULL;
12043 }
12044
12045
12046 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12047 PyObject *resultobj = 0;
12048 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12049 long arg2 ;
12050 void *argp1 = 0 ;
12051 int res1 = 0 ;
12052 long val2 ;
12053 int ecode2 = 0 ;
12054 PyObject * obj0 = 0 ;
12055 PyObject * obj1 = 0 ;
12056 char * kwnames[] = {
12057 (char *) "self",(char *) "type", NULL
12058 };
12059
12060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12062 if (!SWIG_IsOK(res1)) {
12063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12064 }
12065 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12066 ecode2 = SWIG_AsVal_long(obj1, &val2);
12067 if (!SWIG_IsOK(ecode2)) {
12068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12069 }
12070 arg2 = static_cast< long >(val2);
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 (arg1)->SetType(arg2);
12074 wxPyEndAllowThreads(__tstate);
12075 if (PyErr_Occurred()) SWIG_fail;
12076 }
12077 resultobj = SWIG_Py_Void();
12078 return resultobj;
12079 fail:
12080 return NULL;
12081 }
12082
12083
12084 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12085 PyObject *resultobj = 0;
12086 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12087 wxString *arg2 = 0 ;
12088 void *argp1 = 0 ;
12089 int res1 = 0 ;
12090 bool temp2 = false ;
12091 PyObject * obj0 = 0 ;
12092 PyObject * obj1 = 0 ;
12093 char * kwnames[] = {
12094 (char *) "self",(char *) "mimetype", NULL
12095 };
12096
12097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12099 if (!SWIG_IsOK(res1)) {
12100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12101 }
12102 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12103 {
12104 arg2 = wxString_in_helper(obj1);
12105 if (arg2 == NULL) SWIG_fail;
12106 temp2 = true;
12107 }
12108 {
12109 PyThreadState* __tstate = wxPyBeginAllowThreads();
12110 (arg1)->SetMimeType((wxString const &)*arg2);
12111 wxPyEndAllowThreads(__tstate);
12112 if (PyErr_Occurred()) SWIG_fail;
12113 }
12114 resultobj = SWIG_Py_Void();
12115 {
12116 if (temp2)
12117 delete arg2;
12118 }
12119 return resultobj;
12120 fail:
12121 {
12122 if (temp2)
12123 delete arg2;
12124 }
12125 return NULL;
12126 }
12127
12128
12129 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12130 PyObject *obj;
12131 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12132 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12133 return SWIG_Py_Void();
12134 }
12135
12136 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12137 PyObject *resultobj = 0;
12138 wxPyImageHandler *result = 0 ;
12139
12140 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12141 {
12142 PyThreadState* __tstate = wxPyBeginAllowThreads();
12143 result = (wxPyImageHandler *)new wxPyImageHandler();
12144 wxPyEndAllowThreads(__tstate);
12145 if (PyErr_Occurred()) SWIG_fail;
12146 }
12147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12148 return resultobj;
12149 fail:
12150 return NULL;
12151 }
12152
12153
12154 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12155 PyObject *resultobj = 0;
12156 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12157 PyObject *arg2 = (PyObject *) 0 ;
12158 void *argp1 = 0 ;
12159 int res1 = 0 ;
12160 PyObject * obj0 = 0 ;
12161 PyObject * obj1 = 0 ;
12162 char * kwnames[] = {
12163 (char *) "self",(char *) "self", NULL
12164 };
12165
12166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12168 if (!SWIG_IsOK(res1)) {
12169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12170 }
12171 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12172 arg2 = obj1;
12173 {
12174 PyThreadState* __tstate = wxPyBeginAllowThreads();
12175 (arg1)->_SetSelf(arg2);
12176 wxPyEndAllowThreads(__tstate);
12177 if (PyErr_Occurred()) SWIG_fail;
12178 }
12179 resultobj = SWIG_Py_Void();
12180 return resultobj;
12181 fail:
12182 return NULL;
12183 }
12184
12185
12186 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12187 PyObject *obj;
12188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12189 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12190 return SWIG_Py_Void();
12191 }
12192
12193 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12194 return SWIG_Python_InitShadowInstance(args);
12195 }
12196
12197 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12198 PyObject *resultobj = 0;
12199 wxImageHistogram *result = 0 ;
12200
12201 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12202 {
12203 PyThreadState* __tstate = wxPyBeginAllowThreads();
12204 result = (wxImageHistogram *)new wxImageHistogram();
12205 wxPyEndAllowThreads(__tstate);
12206 if (PyErr_Occurred()) SWIG_fail;
12207 }
12208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12209 return resultobj;
12210 fail:
12211 return NULL;
12212 }
12213
12214
12215 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12216 PyObject *resultobj = 0;
12217 byte arg1 ;
12218 byte arg2 ;
12219 byte arg3 ;
12220 unsigned long result;
12221 unsigned char val1 ;
12222 int ecode1 = 0 ;
12223 unsigned char val2 ;
12224 int ecode2 = 0 ;
12225 unsigned char val3 ;
12226 int ecode3 = 0 ;
12227 PyObject * obj0 = 0 ;
12228 PyObject * obj1 = 0 ;
12229 PyObject * obj2 = 0 ;
12230 char * kwnames[] = {
12231 (char *) "r",(char *) "g",(char *) "b", NULL
12232 };
12233
12234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12235 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12236 if (!SWIG_IsOK(ecode1)) {
12237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12238 }
12239 arg1 = static_cast< byte >(val1);
12240 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12241 if (!SWIG_IsOK(ecode2)) {
12242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12243 }
12244 arg2 = static_cast< byte >(val2);
12245 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12246 if (!SWIG_IsOK(ecode3)) {
12247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12248 }
12249 arg3 = static_cast< byte >(val3);
12250 {
12251 PyThreadState* __tstate = wxPyBeginAllowThreads();
12252 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12253 wxPyEndAllowThreads(__tstate);
12254 if (PyErr_Occurred()) SWIG_fail;
12255 }
12256 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12257 return resultobj;
12258 fail:
12259 return NULL;
12260 }
12261
12262
12263 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12264 PyObject *resultobj = 0;
12265 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12266 byte *arg2 = (byte *) 0 ;
12267 byte *arg3 = (byte *) 0 ;
12268 byte *arg4 = (byte *) 0 ;
12269 byte arg5 = (byte) 1 ;
12270 byte arg6 = (byte) 0 ;
12271 byte arg7 = (byte) 0 ;
12272 bool result;
12273 void *argp1 = 0 ;
12274 int res1 = 0 ;
12275 byte temp2 ;
12276 int res2 = SWIG_TMPOBJ ;
12277 byte temp3 ;
12278 int res3 = SWIG_TMPOBJ ;
12279 byte temp4 ;
12280 int res4 = SWIG_TMPOBJ ;
12281 unsigned char val5 ;
12282 int ecode5 = 0 ;
12283 unsigned char val6 ;
12284 int ecode6 = 0 ;
12285 unsigned char val7 ;
12286 int ecode7 = 0 ;
12287 PyObject * obj0 = 0 ;
12288 PyObject * obj1 = 0 ;
12289 PyObject * obj2 = 0 ;
12290 PyObject * obj3 = 0 ;
12291 char * kwnames[] = {
12292 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12293 };
12294
12295 arg2 = &temp2;
12296 arg3 = &temp3;
12297 arg4 = &temp4;
12298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12300 if (!SWIG_IsOK(res1)) {
12301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12302 }
12303 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12304 if (obj1) {
12305 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12306 if (!SWIG_IsOK(ecode5)) {
12307 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12308 }
12309 arg5 = static_cast< byte >(val5);
12310 }
12311 if (obj2) {
12312 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12313 if (!SWIG_IsOK(ecode6)) {
12314 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12315 }
12316 arg6 = static_cast< byte >(val6);
12317 }
12318 if (obj3) {
12319 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12320 if (!SWIG_IsOK(ecode7)) {
12321 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12322 }
12323 arg7 = static_cast< byte >(val7);
12324 }
12325 {
12326 PyThreadState* __tstate = wxPyBeginAllowThreads();
12327 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12328 wxPyEndAllowThreads(__tstate);
12329 if (PyErr_Occurred()) SWIG_fail;
12330 }
12331 {
12332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12333 }
12334 if (SWIG_IsTmpObj(res2)) {
12335 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12336 } else {
12337 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12338 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12339 }
12340 if (SWIG_IsTmpObj(res3)) {
12341 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12342 } else {
12343 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12344 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12345 }
12346 if (SWIG_IsTmpObj(res4)) {
12347 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12348 } else {
12349 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12350 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12351 }
12352 return resultobj;
12353 fail:
12354 return NULL;
12355 }
12356
12357
12358 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12359 PyObject *resultobj = 0;
12360 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12361 unsigned long arg2 ;
12362 unsigned long result;
12363 void *argp1 = 0 ;
12364 int res1 = 0 ;
12365 unsigned long val2 ;
12366 int ecode2 = 0 ;
12367 PyObject * obj0 = 0 ;
12368 PyObject * obj1 = 0 ;
12369 char * kwnames[] = {
12370 (char *) "self",(char *) "key", NULL
12371 };
12372
12373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12375 if (!SWIG_IsOK(res1)) {
12376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12377 }
12378 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12379 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12380 if (!SWIG_IsOK(ecode2)) {
12381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12382 }
12383 arg2 = static_cast< unsigned long >(val2);
12384 {
12385 PyThreadState* __tstate = wxPyBeginAllowThreads();
12386 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12387 wxPyEndAllowThreads(__tstate);
12388 if (PyErr_Occurred()) SWIG_fail;
12389 }
12390 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12391 return resultobj;
12392 fail:
12393 return NULL;
12394 }
12395
12396
12397 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12398 PyObject *resultobj = 0;
12399 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12400 byte arg2 ;
12401 byte arg3 ;
12402 byte arg4 ;
12403 unsigned long result;
12404 void *argp1 = 0 ;
12405 int res1 = 0 ;
12406 unsigned char val2 ;
12407 int ecode2 = 0 ;
12408 unsigned char val3 ;
12409 int ecode3 = 0 ;
12410 unsigned char val4 ;
12411 int ecode4 = 0 ;
12412 PyObject * obj0 = 0 ;
12413 PyObject * obj1 = 0 ;
12414 PyObject * obj2 = 0 ;
12415 PyObject * obj3 = 0 ;
12416 char * kwnames[] = {
12417 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12418 };
12419
12420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12422 if (!SWIG_IsOK(res1)) {
12423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12424 }
12425 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12426 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12427 if (!SWIG_IsOK(ecode2)) {
12428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12429 }
12430 arg2 = static_cast< byte >(val2);
12431 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12432 if (!SWIG_IsOK(ecode3)) {
12433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12434 }
12435 arg3 = static_cast< byte >(val3);
12436 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12437 if (!SWIG_IsOK(ecode4)) {
12438 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12439 }
12440 arg4 = static_cast< byte >(val4);
12441 {
12442 PyThreadState* __tstate = wxPyBeginAllowThreads();
12443 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12444 wxPyEndAllowThreads(__tstate);
12445 if (PyErr_Occurred()) SWIG_fail;
12446 }
12447 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12448 return resultobj;
12449 fail:
12450 return NULL;
12451 }
12452
12453
12454 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12455 PyObject *resultobj = 0;
12456 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12457 wxColour *arg2 = 0 ;
12458 unsigned long result;
12459 void *argp1 = 0 ;
12460 int res1 = 0 ;
12461 wxColour temp2 ;
12462 PyObject * obj0 = 0 ;
12463 PyObject * obj1 = 0 ;
12464 char * kwnames[] = {
12465 (char *) "self",(char *) "colour", NULL
12466 };
12467
12468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12470 if (!SWIG_IsOK(res1)) {
12471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12472 }
12473 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12474 {
12475 arg2 = &temp2;
12476 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12477 }
12478 {
12479 PyThreadState* __tstate = wxPyBeginAllowThreads();
12480 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12481 wxPyEndAllowThreads(__tstate);
12482 if (PyErr_Occurred()) SWIG_fail;
12483 }
12484 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12485 return resultobj;
12486 fail:
12487 return NULL;
12488 }
12489
12490
12491 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12492 PyObject *obj;
12493 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12494 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12495 return SWIG_Py_Void();
12496 }
12497
12498 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12499 return SWIG_Python_InitShadowInstance(args);
12500 }
12501
12502 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12503 PyObject *resultobj = 0;
12504 byte arg1 = (byte) 0 ;
12505 byte arg2 = (byte) 0 ;
12506 byte arg3 = (byte) 0 ;
12507 wxImage_RGBValue *result = 0 ;
12508 unsigned char val1 ;
12509 int ecode1 = 0 ;
12510 unsigned char val2 ;
12511 int ecode2 = 0 ;
12512 unsigned char val3 ;
12513 int ecode3 = 0 ;
12514 PyObject * obj0 = 0 ;
12515 PyObject * obj1 = 0 ;
12516 PyObject * obj2 = 0 ;
12517 char * kwnames[] = {
12518 (char *) "r",(char *) "g",(char *) "b", NULL
12519 };
12520
12521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12522 if (obj0) {
12523 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12524 if (!SWIG_IsOK(ecode1)) {
12525 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12526 }
12527 arg1 = static_cast< byte >(val1);
12528 }
12529 if (obj1) {
12530 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12531 if (!SWIG_IsOK(ecode2)) {
12532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12533 }
12534 arg2 = static_cast< byte >(val2);
12535 }
12536 if (obj2) {
12537 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12538 if (!SWIG_IsOK(ecode3)) {
12539 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12540 }
12541 arg3 = static_cast< byte >(val3);
12542 }
12543 {
12544 PyThreadState* __tstate = wxPyBeginAllowThreads();
12545 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12546 wxPyEndAllowThreads(__tstate);
12547 if (PyErr_Occurred()) SWIG_fail;
12548 }
12549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12550 return resultobj;
12551 fail:
12552 return NULL;
12553 }
12554
12555
12556 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12557 PyObject *resultobj = 0;
12558 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12559 byte arg2 ;
12560 void *argp1 = 0 ;
12561 int res1 = 0 ;
12562 unsigned char val2 ;
12563 int ecode2 = 0 ;
12564 PyObject *swig_obj[2] ;
12565
12566 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12568 if (!SWIG_IsOK(res1)) {
12569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12570 }
12571 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12572 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12573 if (!SWIG_IsOK(ecode2)) {
12574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12575 }
12576 arg2 = static_cast< byte >(val2);
12577 if (arg1) (arg1)->red = arg2;
12578
12579 resultobj = SWIG_Py_Void();
12580 return resultobj;
12581 fail:
12582 return NULL;
12583 }
12584
12585
12586 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12587 PyObject *resultobj = 0;
12588 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12589 byte result;
12590 void *argp1 = 0 ;
12591 int res1 = 0 ;
12592 PyObject *swig_obj[1] ;
12593
12594 if (!args) SWIG_fail;
12595 swig_obj[0] = args;
12596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12597 if (!SWIG_IsOK(res1)) {
12598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12599 }
12600 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12601 result = (byte) ((arg1)->red);
12602 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12603 return resultobj;
12604 fail:
12605 return NULL;
12606 }
12607
12608
12609 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12610 PyObject *resultobj = 0;
12611 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12612 byte arg2 ;
12613 void *argp1 = 0 ;
12614 int res1 = 0 ;
12615 unsigned char val2 ;
12616 int ecode2 = 0 ;
12617 PyObject *swig_obj[2] ;
12618
12619 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12621 if (!SWIG_IsOK(res1)) {
12622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12623 }
12624 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12625 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12626 if (!SWIG_IsOK(ecode2)) {
12627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12628 }
12629 arg2 = static_cast< byte >(val2);
12630 if (arg1) (arg1)->green = arg2;
12631
12632 resultobj = SWIG_Py_Void();
12633 return resultobj;
12634 fail:
12635 return NULL;
12636 }
12637
12638
12639 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12640 PyObject *resultobj = 0;
12641 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12642 byte result;
12643 void *argp1 = 0 ;
12644 int res1 = 0 ;
12645 PyObject *swig_obj[1] ;
12646
12647 if (!args) SWIG_fail;
12648 swig_obj[0] = args;
12649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12650 if (!SWIG_IsOK(res1)) {
12651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12652 }
12653 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12654 result = (byte) ((arg1)->green);
12655 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12656 return resultobj;
12657 fail:
12658 return NULL;
12659 }
12660
12661
12662 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12663 PyObject *resultobj = 0;
12664 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12665 byte arg2 ;
12666 void *argp1 = 0 ;
12667 int res1 = 0 ;
12668 unsigned char val2 ;
12669 int ecode2 = 0 ;
12670 PyObject *swig_obj[2] ;
12671
12672 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12674 if (!SWIG_IsOK(res1)) {
12675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12676 }
12677 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12678 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12679 if (!SWIG_IsOK(ecode2)) {
12680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12681 }
12682 arg2 = static_cast< byte >(val2);
12683 if (arg1) (arg1)->blue = arg2;
12684
12685 resultobj = SWIG_Py_Void();
12686 return resultobj;
12687 fail:
12688 return NULL;
12689 }
12690
12691
12692 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12693 PyObject *resultobj = 0;
12694 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12695 byte result;
12696 void *argp1 = 0 ;
12697 int res1 = 0 ;
12698 PyObject *swig_obj[1] ;
12699
12700 if (!args) SWIG_fail;
12701 swig_obj[0] = args;
12702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12703 if (!SWIG_IsOK(res1)) {
12704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12705 }
12706 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12707 result = (byte) ((arg1)->blue);
12708 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12709 return resultobj;
12710 fail:
12711 return NULL;
12712 }
12713
12714
12715 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12716 PyObject *obj;
12717 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12718 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12719 return SWIG_Py_Void();
12720 }
12721
12722 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12723 return SWIG_Python_InitShadowInstance(args);
12724 }
12725
12726 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12727 PyObject *resultobj = 0;
12728 double arg1 = (double) 0.0 ;
12729 double arg2 = (double) 0.0 ;
12730 double arg3 = (double) 0.0 ;
12731 wxImage_HSVValue *result = 0 ;
12732 double val1 ;
12733 int ecode1 = 0 ;
12734 double val2 ;
12735 int ecode2 = 0 ;
12736 double val3 ;
12737 int ecode3 = 0 ;
12738 PyObject * obj0 = 0 ;
12739 PyObject * obj1 = 0 ;
12740 PyObject * obj2 = 0 ;
12741 char * kwnames[] = {
12742 (char *) "h",(char *) "s",(char *) "v", NULL
12743 };
12744
12745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12746 if (obj0) {
12747 ecode1 = SWIG_AsVal_double(obj0, &val1);
12748 if (!SWIG_IsOK(ecode1)) {
12749 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12750 }
12751 arg1 = static_cast< double >(val1);
12752 }
12753 if (obj1) {
12754 ecode2 = SWIG_AsVal_double(obj1, &val2);
12755 if (!SWIG_IsOK(ecode2)) {
12756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12757 }
12758 arg2 = static_cast< double >(val2);
12759 }
12760 if (obj2) {
12761 ecode3 = SWIG_AsVal_double(obj2, &val3);
12762 if (!SWIG_IsOK(ecode3)) {
12763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12764 }
12765 arg3 = static_cast< double >(val3);
12766 }
12767 {
12768 PyThreadState* __tstate = wxPyBeginAllowThreads();
12769 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12770 wxPyEndAllowThreads(__tstate);
12771 if (PyErr_Occurred()) SWIG_fail;
12772 }
12773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12774 return resultobj;
12775 fail:
12776 return NULL;
12777 }
12778
12779
12780 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12781 PyObject *resultobj = 0;
12782 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12783 double arg2 ;
12784 void *argp1 = 0 ;
12785 int res1 = 0 ;
12786 double val2 ;
12787 int ecode2 = 0 ;
12788 PyObject *swig_obj[2] ;
12789
12790 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12792 if (!SWIG_IsOK(res1)) {
12793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12794 }
12795 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12796 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12797 if (!SWIG_IsOK(ecode2)) {
12798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12799 }
12800 arg2 = static_cast< double >(val2);
12801 if (arg1) (arg1)->hue = arg2;
12802
12803 resultobj = SWIG_Py_Void();
12804 return resultobj;
12805 fail:
12806 return NULL;
12807 }
12808
12809
12810 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12811 PyObject *resultobj = 0;
12812 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12813 double result;
12814 void *argp1 = 0 ;
12815 int res1 = 0 ;
12816 PyObject *swig_obj[1] ;
12817
12818 if (!args) SWIG_fail;
12819 swig_obj[0] = args;
12820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12821 if (!SWIG_IsOK(res1)) {
12822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12823 }
12824 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12825 result = (double) ((arg1)->hue);
12826 resultobj = SWIG_From_double(static_cast< double >(result));
12827 return resultobj;
12828 fail:
12829 return NULL;
12830 }
12831
12832
12833 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12834 PyObject *resultobj = 0;
12835 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12836 double arg2 ;
12837 void *argp1 = 0 ;
12838 int res1 = 0 ;
12839 double val2 ;
12840 int ecode2 = 0 ;
12841 PyObject *swig_obj[2] ;
12842
12843 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12845 if (!SWIG_IsOK(res1)) {
12846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12847 }
12848 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12849 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12850 if (!SWIG_IsOK(ecode2)) {
12851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12852 }
12853 arg2 = static_cast< double >(val2);
12854 if (arg1) (arg1)->saturation = arg2;
12855
12856 resultobj = SWIG_Py_Void();
12857 return resultobj;
12858 fail:
12859 return NULL;
12860 }
12861
12862
12863 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12864 PyObject *resultobj = 0;
12865 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12866 double result;
12867 void *argp1 = 0 ;
12868 int res1 = 0 ;
12869 PyObject *swig_obj[1] ;
12870
12871 if (!args) SWIG_fail;
12872 swig_obj[0] = args;
12873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12874 if (!SWIG_IsOK(res1)) {
12875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12876 }
12877 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12878 result = (double) ((arg1)->saturation);
12879 resultobj = SWIG_From_double(static_cast< double >(result));
12880 return resultobj;
12881 fail:
12882 return NULL;
12883 }
12884
12885
12886 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12887 PyObject *resultobj = 0;
12888 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12889 double arg2 ;
12890 void *argp1 = 0 ;
12891 int res1 = 0 ;
12892 double val2 ;
12893 int ecode2 = 0 ;
12894 PyObject *swig_obj[2] ;
12895
12896 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12898 if (!SWIG_IsOK(res1)) {
12899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12900 }
12901 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12902 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12903 if (!SWIG_IsOK(ecode2)) {
12904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12905 }
12906 arg2 = static_cast< double >(val2);
12907 if (arg1) (arg1)->value = arg2;
12908
12909 resultobj = SWIG_Py_Void();
12910 return resultobj;
12911 fail:
12912 return NULL;
12913 }
12914
12915
12916 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12917 PyObject *resultobj = 0;
12918 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12919 double result;
12920 void *argp1 = 0 ;
12921 int res1 = 0 ;
12922 PyObject *swig_obj[1] ;
12923
12924 if (!args) SWIG_fail;
12925 swig_obj[0] = args;
12926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12927 if (!SWIG_IsOK(res1)) {
12928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12929 }
12930 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12931 result = (double) ((arg1)->value);
12932 resultobj = SWIG_From_double(static_cast< double >(result));
12933 return resultobj;
12934 fail:
12935 return NULL;
12936 }
12937
12938
12939 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12940 PyObject *obj;
12941 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12942 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12943 return SWIG_Py_Void();
12944 }
12945
12946 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12947 return SWIG_Python_InitShadowInstance(args);
12948 }
12949
12950 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12951 PyObject *resultobj = 0;
12952 wxString *arg1 = 0 ;
12953 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12954 int arg3 = (int) -1 ;
12955 wxImage *result = 0 ;
12956 bool temp1 = false ;
12957 long val2 ;
12958 int ecode2 = 0 ;
12959 int val3 ;
12960 int ecode3 = 0 ;
12961 PyObject * obj0 = 0 ;
12962 PyObject * obj1 = 0 ;
12963 PyObject * obj2 = 0 ;
12964 char * kwnames[] = {
12965 (char *) "name",(char *) "type",(char *) "index", NULL
12966 };
12967
12968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12969 {
12970 arg1 = wxString_in_helper(obj0);
12971 if (arg1 == NULL) SWIG_fail;
12972 temp1 = true;
12973 }
12974 if (obj1) {
12975 ecode2 = SWIG_AsVal_long(obj1, &val2);
12976 if (!SWIG_IsOK(ecode2)) {
12977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12978 }
12979 arg2 = static_cast< long >(val2);
12980 }
12981 if (obj2) {
12982 ecode3 = SWIG_AsVal_int(obj2, &val3);
12983 if (!SWIG_IsOK(ecode3)) {
12984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12985 }
12986 arg3 = static_cast< int >(val3);
12987 }
12988 {
12989 PyThreadState* __tstate = wxPyBeginAllowThreads();
12990 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12991 wxPyEndAllowThreads(__tstate);
12992 if (PyErr_Occurred()) SWIG_fail;
12993 }
12994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12995 {
12996 if (temp1)
12997 delete arg1;
12998 }
12999 return resultobj;
13000 fail:
13001 {
13002 if (temp1)
13003 delete arg1;
13004 }
13005 return NULL;
13006 }
13007
13008
13009 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13010 PyObject *resultobj = 0;
13011 wxImage *arg1 = (wxImage *) 0 ;
13012 void *argp1 = 0 ;
13013 int res1 = 0 ;
13014 PyObject *swig_obj[1] ;
13015
13016 if (!args) SWIG_fail;
13017 swig_obj[0] = args;
13018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13019 if (!SWIG_IsOK(res1)) {
13020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13021 }
13022 arg1 = reinterpret_cast< wxImage * >(argp1);
13023 {
13024 PyThreadState* __tstate = wxPyBeginAllowThreads();
13025 delete arg1;
13026
13027 wxPyEndAllowThreads(__tstate);
13028 if (PyErr_Occurred()) SWIG_fail;
13029 }
13030 resultobj = SWIG_Py_Void();
13031 return resultobj;
13032 fail:
13033 return NULL;
13034 }
13035
13036
13037 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13038 PyObject *resultobj = 0;
13039 wxString *arg1 = 0 ;
13040 wxString *arg2 = 0 ;
13041 int arg3 = (int) -1 ;
13042 wxImage *result = 0 ;
13043 bool temp1 = false ;
13044 bool temp2 = false ;
13045 int val3 ;
13046 int ecode3 = 0 ;
13047 PyObject * obj0 = 0 ;
13048 PyObject * obj1 = 0 ;
13049 PyObject * obj2 = 0 ;
13050 char * kwnames[] = {
13051 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13052 };
13053
13054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13055 {
13056 arg1 = wxString_in_helper(obj0);
13057 if (arg1 == NULL) SWIG_fail;
13058 temp1 = true;
13059 }
13060 {
13061 arg2 = wxString_in_helper(obj1);
13062 if (arg2 == NULL) SWIG_fail;
13063 temp2 = true;
13064 }
13065 if (obj2) {
13066 ecode3 = SWIG_AsVal_int(obj2, &val3);
13067 if (!SWIG_IsOK(ecode3)) {
13068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13069 }
13070 arg3 = static_cast< int >(val3);
13071 }
13072 {
13073 PyThreadState* __tstate = wxPyBeginAllowThreads();
13074 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13075 wxPyEndAllowThreads(__tstate);
13076 if (PyErr_Occurred()) SWIG_fail;
13077 }
13078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13079 {
13080 if (temp1)
13081 delete arg1;
13082 }
13083 {
13084 if (temp2)
13085 delete arg2;
13086 }
13087 return resultobj;
13088 fail:
13089 {
13090 if (temp1)
13091 delete arg1;
13092 }
13093 {
13094 if (temp2)
13095 delete arg2;
13096 }
13097 return NULL;
13098 }
13099
13100
13101 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13102 PyObject *resultobj = 0;
13103 wxInputStream *arg1 = 0 ;
13104 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13105 int arg3 = (int) -1 ;
13106 wxImage *result = 0 ;
13107 wxPyInputStream *temp1 ;
13108 bool created1 ;
13109 long val2 ;
13110 int ecode2 = 0 ;
13111 int val3 ;
13112 int ecode3 = 0 ;
13113 PyObject * obj0 = 0 ;
13114 PyObject * obj1 = 0 ;
13115 PyObject * obj2 = 0 ;
13116 char * kwnames[] = {
13117 (char *) "stream",(char *) "type",(char *) "index", NULL
13118 };
13119
13120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13121 {
13122 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13123 arg1 = temp1->m_wxis;
13124 created1 = false;
13125 } else {
13126 PyErr_Clear(); // clear the failure of the wxPyConvert above
13127 arg1 = wxPyCBInputStream_create(obj0, false);
13128 if (arg1 == NULL) {
13129 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13130 SWIG_fail;
13131 }
13132 created1 = true;
13133 }
13134 }
13135 if (obj1) {
13136 ecode2 = SWIG_AsVal_long(obj1, &val2);
13137 if (!SWIG_IsOK(ecode2)) {
13138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13139 }
13140 arg2 = static_cast< long >(val2);
13141 }
13142 if (obj2) {
13143 ecode3 = SWIG_AsVal_int(obj2, &val3);
13144 if (!SWIG_IsOK(ecode3)) {
13145 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13146 }
13147 arg3 = static_cast< int >(val3);
13148 }
13149 {
13150 PyThreadState* __tstate = wxPyBeginAllowThreads();
13151 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13152 wxPyEndAllowThreads(__tstate);
13153 if (PyErr_Occurred()) SWIG_fail;
13154 }
13155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13156 {
13157 if (created1) delete arg1;
13158 }
13159 return resultobj;
13160 fail:
13161 {
13162 if (created1) delete arg1;
13163 }
13164 return NULL;
13165 }
13166
13167
13168 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13169 PyObject *resultobj = 0;
13170 wxInputStream *arg1 = 0 ;
13171 wxString *arg2 = 0 ;
13172 int arg3 = (int) -1 ;
13173 wxImage *result = 0 ;
13174 wxPyInputStream *temp1 ;
13175 bool created1 ;
13176 bool temp2 = false ;
13177 int val3 ;
13178 int ecode3 = 0 ;
13179 PyObject * obj0 = 0 ;
13180 PyObject * obj1 = 0 ;
13181 PyObject * obj2 = 0 ;
13182 char * kwnames[] = {
13183 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13184 };
13185
13186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13187 {
13188 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13189 arg1 = temp1->m_wxis;
13190 created1 = false;
13191 } else {
13192 PyErr_Clear(); // clear the failure of the wxPyConvert above
13193 arg1 = wxPyCBInputStream_create(obj0, false);
13194 if (arg1 == NULL) {
13195 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13196 SWIG_fail;
13197 }
13198 created1 = true;
13199 }
13200 }
13201 {
13202 arg2 = wxString_in_helper(obj1);
13203 if (arg2 == NULL) SWIG_fail;
13204 temp2 = true;
13205 }
13206 if (obj2) {
13207 ecode3 = SWIG_AsVal_int(obj2, &val3);
13208 if (!SWIG_IsOK(ecode3)) {
13209 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13210 }
13211 arg3 = static_cast< int >(val3);
13212 }
13213 {
13214 PyThreadState* __tstate = wxPyBeginAllowThreads();
13215 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13216 wxPyEndAllowThreads(__tstate);
13217 if (PyErr_Occurred()) SWIG_fail;
13218 }
13219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13220 {
13221 if (created1) delete arg1;
13222 }
13223 {
13224 if (temp2)
13225 delete arg2;
13226 }
13227 return resultobj;
13228 fail:
13229 {
13230 if (created1) delete arg1;
13231 }
13232 {
13233 if (temp2)
13234 delete arg2;
13235 }
13236 return NULL;
13237 }
13238
13239
13240 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13241 PyObject *resultobj = 0;
13242 int arg1 = (int) 0 ;
13243 int arg2 = (int) 0 ;
13244 bool arg3 = (bool) true ;
13245 wxImage *result = 0 ;
13246 int val1 ;
13247 int ecode1 = 0 ;
13248 int val2 ;
13249 int ecode2 = 0 ;
13250 bool val3 ;
13251 int ecode3 = 0 ;
13252 PyObject * obj0 = 0 ;
13253 PyObject * obj1 = 0 ;
13254 PyObject * obj2 = 0 ;
13255 char * kwnames[] = {
13256 (char *) "width",(char *) "height",(char *) "clear", NULL
13257 };
13258
13259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13260 if (obj0) {
13261 ecode1 = SWIG_AsVal_int(obj0, &val1);
13262 if (!SWIG_IsOK(ecode1)) {
13263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13264 }
13265 arg1 = static_cast< int >(val1);
13266 }
13267 if (obj1) {
13268 ecode2 = SWIG_AsVal_int(obj1, &val2);
13269 if (!SWIG_IsOK(ecode2)) {
13270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13271 }
13272 arg2 = static_cast< int >(val2);
13273 }
13274 if (obj2) {
13275 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13276 if (!SWIG_IsOK(ecode3)) {
13277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13278 }
13279 arg3 = static_cast< bool >(val3);
13280 }
13281 {
13282 PyThreadState* __tstate = wxPyBeginAllowThreads();
13283 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13284 wxPyEndAllowThreads(__tstate);
13285 if (PyErr_Occurred()) SWIG_fail;
13286 }
13287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13288 return resultobj;
13289 fail:
13290 return NULL;
13291 }
13292
13293
13294 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13295 PyObject *resultobj = 0;
13296 wxBitmap *arg1 = 0 ;
13297 wxImage *result = 0 ;
13298 void *argp1 = 0 ;
13299 int res1 = 0 ;
13300 PyObject * obj0 = 0 ;
13301 char * kwnames[] = {
13302 (char *) "bitmap", NULL
13303 };
13304
13305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13306 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13307 if (!SWIG_IsOK(res1)) {
13308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13309 }
13310 if (!argp1) {
13311 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13312 }
13313 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13314 {
13315 if (!wxPyCheckForApp()) SWIG_fail;
13316 PyThreadState* __tstate = wxPyBeginAllowThreads();
13317 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13318 wxPyEndAllowThreads(__tstate);
13319 if (PyErr_Occurred()) SWIG_fail;
13320 }
13321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13322 return resultobj;
13323 fail:
13324 return NULL;
13325 }
13326
13327
13328 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13329 PyObject *resultobj = 0;
13330 int arg1 ;
13331 int arg2 ;
13332 buffer arg3 ;
13333 int arg4 ;
13334 wxImage *result = 0 ;
13335 int val1 ;
13336 int ecode1 = 0 ;
13337 int val2 ;
13338 int ecode2 = 0 ;
13339 PyObject * obj0 = 0 ;
13340 PyObject * obj1 = 0 ;
13341 PyObject * obj2 = 0 ;
13342 char * kwnames[] = {
13343 (char *) "width",(char *) "height",(char *) "data", NULL
13344 };
13345
13346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13347 ecode1 = SWIG_AsVal_int(obj0, &val1);
13348 if (!SWIG_IsOK(ecode1)) {
13349 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13350 }
13351 arg1 = static_cast< int >(val1);
13352 ecode2 = SWIG_AsVal_int(obj1, &val2);
13353 if (!SWIG_IsOK(ecode2)) {
13354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13355 }
13356 arg2 = static_cast< int >(val2);
13357 {
13358 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13359 }
13360 {
13361 PyThreadState* __tstate = wxPyBeginAllowThreads();
13362 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13363 wxPyEndAllowThreads(__tstate);
13364 if (PyErr_Occurred()) SWIG_fail;
13365 }
13366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13367 return resultobj;
13368 fail:
13369 return NULL;
13370 }
13371
13372
13373 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13374 PyObject *resultobj = 0;
13375 int arg1 ;
13376 int arg2 ;
13377 buffer arg3 ;
13378 int arg4 ;
13379 buffer arg5 ;
13380 int arg6 ;
13381 wxImage *result = 0 ;
13382 int val1 ;
13383 int ecode1 = 0 ;
13384 int val2 ;
13385 int ecode2 = 0 ;
13386 PyObject * obj0 = 0 ;
13387 PyObject * obj1 = 0 ;
13388 PyObject * obj2 = 0 ;
13389 PyObject * obj3 = 0 ;
13390 char * kwnames[] = {
13391 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13392 };
13393
13394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13395 ecode1 = SWIG_AsVal_int(obj0, &val1);
13396 if (!SWIG_IsOK(ecode1)) {
13397 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13398 }
13399 arg1 = static_cast< int >(val1);
13400 ecode2 = SWIG_AsVal_int(obj1, &val2);
13401 if (!SWIG_IsOK(ecode2)) {
13402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13403 }
13404 arg2 = static_cast< int >(val2);
13405 {
13406 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13407 }
13408 {
13409 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13410 }
13411 {
13412 PyThreadState* __tstate = wxPyBeginAllowThreads();
13413 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13414 wxPyEndAllowThreads(__tstate);
13415 if (PyErr_Occurred()) SWIG_fail;
13416 }
13417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13418 return resultobj;
13419 fail:
13420 return NULL;
13421 }
13422
13423
13424 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13425 PyObject *resultobj = 0;
13426 wxImage *arg1 = (wxImage *) 0 ;
13427 int arg2 ;
13428 int arg3 ;
13429 bool arg4 = (bool) true ;
13430 void *argp1 = 0 ;
13431 int res1 = 0 ;
13432 int val2 ;
13433 int ecode2 = 0 ;
13434 int val3 ;
13435 int ecode3 = 0 ;
13436 bool val4 ;
13437 int ecode4 = 0 ;
13438 PyObject * obj0 = 0 ;
13439 PyObject * obj1 = 0 ;
13440 PyObject * obj2 = 0 ;
13441 PyObject * obj3 = 0 ;
13442 char * kwnames[] = {
13443 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13444 };
13445
13446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13448 if (!SWIG_IsOK(res1)) {
13449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13450 }
13451 arg1 = reinterpret_cast< wxImage * >(argp1);
13452 ecode2 = SWIG_AsVal_int(obj1, &val2);
13453 if (!SWIG_IsOK(ecode2)) {
13454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13455 }
13456 arg2 = static_cast< int >(val2);
13457 ecode3 = SWIG_AsVal_int(obj2, &val3);
13458 if (!SWIG_IsOK(ecode3)) {
13459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13460 }
13461 arg3 = static_cast< int >(val3);
13462 if (obj3) {
13463 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13464 if (!SWIG_IsOK(ecode4)) {
13465 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13466 }
13467 arg4 = static_cast< bool >(val4);
13468 }
13469 {
13470 PyThreadState* __tstate = wxPyBeginAllowThreads();
13471 (arg1)->Create(arg2,arg3,arg4);
13472 wxPyEndAllowThreads(__tstate);
13473 if (PyErr_Occurred()) SWIG_fail;
13474 }
13475 resultobj = SWIG_Py_Void();
13476 return resultobj;
13477 fail:
13478 return NULL;
13479 }
13480
13481
13482 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13483 PyObject *resultobj = 0;
13484 wxImage *arg1 = (wxImage *) 0 ;
13485 void *argp1 = 0 ;
13486 int res1 = 0 ;
13487 PyObject *swig_obj[1] ;
13488
13489 if (!args) SWIG_fail;
13490 swig_obj[0] = args;
13491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13492 if (!SWIG_IsOK(res1)) {
13493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13494 }
13495 arg1 = reinterpret_cast< wxImage * >(argp1);
13496 {
13497 PyThreadState* __tstate = wxPyBeginAllowThreads();
13498 (arg1)->Destroy();
13499 wxPyEndAllowThreads(__tstate);
13500 if (PyErr_Occurred()) SWIG_fail;
13501 }
13502 resultobj = SWIG_Py_Void();
13503 return resultobj;
13504 fail:
13505 return NULL;
13506 }
13507
13508
13509 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13510 PyObject *resultobj = 0;
13511 wxImage *arg1 = (wxImage *) 0 ;
13512 int arg2 ;
13513 int arg3 ;
13514 SwigValueWrapper<wxImage > result;
13515 void *argp1 = 0 ;
13516 int res1 = 0 ;
13517 int val2 ;
13518 int ecode2 = 0 ;
13519 int val3 ;
13520 int ecode3 = 0 ;
13521 PyObject * obj0 = 0 ;
13522 PyObject * obj1 = 0 ;
13523 PyObject * obj2 = 0 ;
13524 char * kwnames[] = {
13525 (char *) "self",(char *) "width",(char *) "height", NULL
13526 };
13527
13528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13530 if (!SWIG_IsOK(res1)) {
13531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13532 }
13533 arg1 = reinterpret_cast< wxImage * >(argp1);
13534 ecode2 = SWIG_AsVal_int(obj1, &val2);
13535 if (!SWIG_IsOK(ecode2)) {
13536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13537 }
13538 arg2 = static_cast< int >(val2);
13539 ecode3 = SWIG_AsVal_int(obj2, &val3);
13540 if (!SWIG_IsOK(ecode3)) {
13541 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13542 }
13543 arg3 = static_cast< int >(val3);
13544 {
13545 PyThreadState* __tstate = wxPyBeginAllowThreads();
13546 result = (arg1)->Scale(arg2,arg3);
13547 wxPyEndAllowThreads(__tstate);
13548 if (PyErr_Occurred()) SWIG_fail;
13549 }
13550 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13551 return resultobj;
13552 fail:
13553 return NULL;
13554 }
13555
13556
13557 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13558 PyObject *resultobj = 0;
13559 wxImage *arg1 = (wxImage *) 0 ;
13560 int arg2 ;
13561 int arg3 ;
13562 SwigValueWrapper<wxImage > result;
13563 void *argp1 = 0 ;
13564 int res1 = 0 ;
13565 int val2 ;
13566 int ecode2 = 0 ;
13567 int val3 ;
13568 int ecode3 = 0 ;
13569 PyObject * obj0 = 0 ;
13570 PyObject * obj1 = 0 ;
13571 PyObject * obj2 = 0 ;
13572 char * kwnames[] = {
13573 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13574 };
13575
13576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13578 if (!SWIG_IsOK(res1)) {
13579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13580 }
13581 arg1 = reinterpret_cast< wxImage * >(argp1);
13582 ecode2 = SWIG_AsVal_int(obj1, &val2);
13583 if (!SWIG_IsOK(ecode2)) {
13584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13585 }
13586 arg2 = static_cast< int >(val2);
13587 ecode3 = SWIG_AsVal_int(obj2, &val3);
13588 if (!SWIG_IsOK(ecode3)) {
13589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13590 }
13591 arg3 = static_cast< int >(val3);
13592 {
13593 PyThreadState* __tstate = wxPyBeginAllowThreads();
13594 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13595 wxPyEndAllowThreads(__tstate);
13596 if (PyErr_Occurred()) SWIG_fail;
13597 }
13598 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13599 return resultobj;
13600 fail:
13601 return NULL;
13602 }
13603
13604
13605 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13606 PyObject *resultobj = 0;
13607 wxImage *arg1 = (wxImage *) 0 ;
13608 int arg2 ;
13609 int arg3 ;
13610 wxImage *result = 0 ;
13611 void *argp1 = 0 ;
13612 int res1 = 0 ;
13613 int val2 ;
13614 int ecode2 = 0 ;
13615 int val3 ;
13616 int ecode3 = 0 ;
13617 PyObject * obj0 = 0 ;
13618 PyObject * obj1 = 0 ;
13619 PyObject * obj2 = 0 ;
13620 char * kwnames[] = {
13621 (char *) "self",(char *) "width",(char *) "height", NULL
13622 };
13623
13624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13626 if (!SWIG_IsOK(res1)) {
13627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13628 }
13629 arg1 = reinterpret_cast< wxImage * >(argp1);
13630 ecode2 = SWIG_AsVal_int(obj1, &val2);
13631 if (!SWIG_IsOK(ecode2)) {
13632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13633 }
13634 arg2 = static_cast< int >(val2);
13635 ecode3 = SWIG_AsVal_int(obj2, &val3);
13636 if (!SWIG_IsOK(ecode3)) {
13637 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13638 }
13639 arg3 = static_cast< int >(val3);
13640 {
13641 PyThreadState* __tstate = wxPyBeginAllowThreads();
13642 {
13643 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13644 result = (wxImage *) &_result_ref;
13645 }
13646 wxPyEndAllowThreads(__tstate);
13647 if (PyErr_Occurred()) SWIG_fail;
13648 }
13649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13650 return resultobj;
13651 fail:
13652 return NULL;
13653 }
13654
13655
13656 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13657 PyObject *resultobj = 0;
13658 wxImage *arg1 = (wxImage *) 0 ;
13659 wxSize *arg2 = 0 ;
13660 wxPoint *arg3 = 0 ;
13661 int arg4 = (int) -1 ;
13662 int arg5 = (int) -1 ;
13663 int arg6 = (int) -1 ;
13664 wxImage *result = 0 ;
13665 void *argp1 = 0 ;
13666 int res1 = 0 ;
13667 wxSize temp2 ;
13668 wxPoint temp3 ;
13669 int val4 ;
13670 int ecode4 = 0 ;
13671 int val5 ;
13672 int ecode5 = 0 ;
13673 int val6 ;
13674 int ecode6 = 0 ;
13675 PyObject * obj0 = 0 ;
13676 PyObject * obj1 = 0 ;
13677 PyObject * obj2 = 0 ;
13678 PyObject * obj3 = 0 ;
13679 PyObject * obj4 = 0 ;
13680 PyObject * obj5 = 0 ;
13681 char * kwnames[] = {
13682 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13683 };
13684
13685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13687 if (!SWIG_IsOK(res1)) {
13688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13689 }
13690 arg1 = reinterpret_cast< wxImage * >(argp1);
13691 {
13692 arg2 = &temp2;
13693 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13694 }
13695 {
13696 arg3 = &temp3;
13697 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13698 }
13699 if (obj3) {
13700 ecode4 = SWIG_AsVal_int(obj3, &val4);
13701 if (!SWIG_IsOK(ecode4)) {
13702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13703 }
13704 arg4 = static_cast< int >(val4);
13705 }
13706 if (obj4) {
13707 ecode5 = SWIG_AsVal_int(obj4, &val5);
13708 if (!SWIG_IsOK(ecode5)) {
13709 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13710 }
13711 arg5 = static_cast< int >(val5);
13712 }
13713 if (obj5) {
13714 ecode6 = SWIG_AsVal_int(obj5, &val6);
13715 if (!SWIG_IsOK(ecode6)) {
13716 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13717 }
13718 arg6 = static_cast< int >(val6);
13719 }
13720 {
13721 PyThreadState* __tstate = wxPyBeginAllowThreads();
13722 {
13723 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13724 result = (wxImage *) &_result_ref;
13725 }
13726 wxPyEndAllowThreads(__tstate);
13727 if (PyErr_Occurred()) SWIG_fail;
13728 }
13729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13730 return resultobj;
13731 fail:
13732 return NULL;
13733 }
13734
13735
13736 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13737 PyObject *resultobj = 0;
13738 wxImage *arg1 = (wxImage *) 0 ;
13739 int arg2 ;
13740 int arg3 ;
13741 byte arg4 ;
13742 byte arg5 ;
13743 byte arg6 ;
13744 void *argp1 = 0 ;
13745 int res1 = 0 ;
13746 int val2 ;
13747 int ecode2 = 0 ;
13748 int val3 ;
13749 int ecode3 = 0 ;
13750 unsigned char val4 ;
13751 int ecode4 = 0 ;
13752 unsigned char val5 ;
13753 int ecode5 = 0 ;
13754 unsigned char val6 ;
13755 int ecode6 = 0 ;
13756 PyObject * obj0 = 0 ;
13757 PyObject * obj1 = 0 ;
13758 PyObject * obj2 = 0 ;
13759 PyObject * obj3 = 0 ;
13760 PyObject * obj4 = 0 ;
13761 PyObject * obj5 = 0 ;
13762 char * kwnames[] = {
13763 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13764 };
13765
13766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13768 if (!SWIG_IsOK(res1)) {
13769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13770 }
13771 arg1 = reinterpret_cast< wxImage * >(argp1);
13772 ecode2 = SWIG_AsVal_int(obj1, &val2);
13773 if (!SWIG_IsOK(ecode2)) {
13774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13775 }
13776 arg2 = static_cast< int >(val2);
13777 ecode3 = SWIG_AsVal_int(obj2, &val3);
13778 if (!SWIG_IsOK(ecode3)) {
13779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13780 }
13781 arg3 = static_cast< int >(val3);
13782 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13783 if (!SWIG_IsOK(ecode4)) {
13784 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13785 }
13786 arg4 = static_cast< byte >(val4);
13787 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13788 if (!SWIG_IsOK(ecode5)) {
13789 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13790 }
13791 arg5 = static_cast< byte >(val5);
13792 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13793 if (!SWIG_IsOK(ecode6)) {
13794 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13795 }
13796 arg6 = static_cast< byte >(val6);
13797 {
13798 PyThreadState* __tstate = wxPyBeginAllowThreads();
13799 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13800 wxPyEndAllowThreads(__tstate);
13801 if (PyErr_Occurred()) SWIG_fail;
13802 }
13803 resultobj = SWIG_Py_Void();
13804 return resultobj;
13805 fail:
13806 return NULL;
13807 }
13808
13809
13810 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13811 PyObject *resultobj = 0;
13812 wxImage *arg1 = (wxImage *) 0 ;
13813 wxRect *arg2 = 0 ;
13814 byte arg3 ;
13815 byte arg4 ;
13816 byte arg5 ;
13817 void *argp1 = 0 ;
13818 int res1 = 0 ;
13819 wxRect temp2 ;
13820 unsigned char val3 ;
13821 int ecode3 = 0 ;
13822 unsigned char val4 ;
13823 int ecode4 = 0 ;
13824 unsigned char val5 ;
13825 int ecode5 = 0 ;
13826 PyObject * obj0 = 0 ;
13827 PyObject * obj1 = 0 ;
13828 PyObject * obj2 = 0 ;
13829 PyObject * obj3 = 0 ;
13830 PyObject * obj4 = 0 ;
13831 char * kwnames[] = {
13832 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13833 };
13834
13835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13837 if (!SWIG_IsOK(res1)) {
13838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13839 }
13840 arg1 = reinterpret_cast< wxImage * >(argp1);
13841 {
13842 arg2 = &temp2;
13843 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13844 }
13845 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13846 if (!SWIG_IsOK(ecode3)) {
13847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13848 }
13849 arg3 = static_cast< byte >(val3);
13850 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13851 if (!SWIG_IsOK(ecode4)) {
13852 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13853 }
13854 arg4 = static_cast< byte >(val4);
13855 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13856 if (!SWIG_IsOK(ecode5)) {
13857 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13858 }
13859 arg5 = static_cast< byte >(val5);
13860 {
13861 PyThreadState* __tstate = wxPyBeginAllowThreads();
13862 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13863 wxPyEndAllowThreads(__tstate);
13864 if (PyErr_Occurred()) SWIG_fail;
13865 }
13866 resultobj = SWIG_Py_Void();
13867 return resultobj;
13868 fail:
13869 return NULL;
13870 }
13871
13872
13873 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13874 PyObject *resultobj = 0;
13875 wxImage *arg1 = (wxImage *) 0 ;
13876 int arg2 ;
13877 int arg3 ;
13878 byte result;
13879 void *argp1 = 0 ;
13880 int res1 = 0 ;
13881 int val2 ;
13882 int ecode2 = 0 ;
13883 int val3 ;
13884 int ecode3 = 0 ;
13885 PyObject * obj0 = 0 ;
13886 PyObject * obj1 = 0 ;
13887 PyObject * obj2 = 0 ;
13888 char * kwnames[] = {
13889 (char *) "self",(char *) "x",(char *) "y", NULL
13890 };
13891
13892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13894 if (!SWIG_IsOK(res1)) {
13895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13896 }
13897 arg1 = reinterpret_cast< wxImage * >(argp1);
13898 ecode2 = SWIG_AsVal_int(obj1, &val2);
13899 if (!SWIG_IsOK(ecode2)) {
13900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13901 }
13902 arg2 = static_cast< int >(val2);
13903 ecode3 = SWIG_AsVal_int(obj2, &val3);
13904 if (!SWIG_IsOK(ecode3)) {
13905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13906 }
13907 arg3 = static_cast< int >(val3);
13908 {
13909 PyThreadState* __tstate = wxPyBeginAllowThreads();
13910 result = (byte)(arg1)->GetRed(arg2,arg3);
13911 wxPyEndAllowThreads(__tstate);
13912 if (PyErr_Occurred()) SWIG_fail;
13913 }
13914 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13915 return resultobj;
13916 fail:
13917 return NULL;
13918 }
13919
13920
13921 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13922 PyObject *resultobj = 0;
13923 wxImage *arg1 = (wxImage *) 0 ;
13924 int arg2 ;
13925 int arg3 ;
13926 byte result;
13927 void *argp1 = 0 ;
13928 int res1 = 0 ;
13929 int val2 ;
13930 int ecode2 = 0 ;
13931 int val3 ;
13932 int ecode3 = 0 ;
13933 PyObject * obj0 = 0 ;
13934 PyObject * obj1 = 0 ;
13935 PyObject * obj2 = 0 ;
13936 char * kwnames[] = {
13937 (char *) "self",(char *) "x",(char *) "y", NULL
13938 };
13939
13940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13942 if (!SWIG_IsOK(res1)) {
13943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13944 }
13945 arg1 = reinterpret_cast< wxImage * >(argp1);
13946 ecode2 = SWIG_AsVal_int(obj1, &val2);
13947 if (!SWIG_IsOK(ecode2)) {
13948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13949 }
13950 arg2 = static_cast< int >(val2);
13951 ecode3 = SWIG_AsVal_int(obj2, &val3);
13952 if (!SWIG_IsOK(ecode3)) {
13953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13954 }
13955 arg3 = static_cast< int >(val3);
13956 {
13957 PyThreadState* __tstate = wxPyBeginAllowThreads();
13958 result = (byte)(arg1)->GetGreen(arg2,arg3);
13959 wxPyEndAllowThreads(__tstate);
13960 if (PyErr_Occurred()) SWIG_fail;
13961 }
13962 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13963 return resultobj;
13964 fail:
13965 return NULL;
13966 }
13967
13968
13969 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13970 PyObject *resultobj = 0;
13971 wxImage *arg1 = (wxImage *) 0 ;
13972 int arg2 ;
13973 int arg3 ;
13974 byte result;
13975 void *argp1 = 0 ;
13976 int res1 = 0 ;
13977 int val2 ;
13978 int ecode2 = 0 ;
13979 int val3 ;
13980 int ecode3 = 0 ;
13981 PyObject * obj0 = 0 ;
13982 PyObject * obj1 = 0 ;
13983 PyObject * obj2 = 0 ;
13984 char * kwnames[] = {
13985 (char *) "self",(char *) "x",(char *) "y", NULL
13986 };
13987
13988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13990 if (!SWIG_IsOK(res1)) {
13991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13992 }
13993 arg1 = reinterpret_cast< wxImage * >(argp1);
13994 ecode2 = SWIG_AsVal_int(obj1, &val2);
13995 if (!SWIG_IsOK(ecode2)) {
13996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13997 }
13998 arg2 = static_cast< int >(val2);
13999 ecode3 = SWIG_AsVal_int(obj2, &val3);
14000 if (!SWIG_IsOK(ecode3)) {
14001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14002 }
14003 arg3 = static_cast< int >(val3);
14004 {
14005 PyThreadState* __tstate = wxPyBeginAllowThreads();
14006 result = (byte)(arg1)->GetBlue(arg2,arg3);
14007 wxPyEndAllowThreads(__tstate);
14008 if (PyErr_Occurred()) SWIG_fail;
14009 }
14010 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14011 return resultobj;
14012 fail:
14013 return NULL;
14014 }
14015
14016
14017 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14018 PyObject *resultobj = 0;
14019 wxImage *arg1 = (wxImage *) 0 ;
14020 int arg2 ;
14021 int arg3 ;
14022 byte arg4 ;
14023 void *argp1 = 0 ;
14024 int res1 = 0 ;
14025 int val2 ;
14026 int ecode2 = 0 ;
14027 int val3 ;
14028 int ecode3 = 0 ;
14029 unsigned char val4 ;
14030 int ecode4 = 0 ;
14031 PyObject * obj0 = 0 ;
14032 PyObject * obj1 = 0 ;
14033 PyObject * obj2 = 0 ;
14034 PyObject * obj3 = 0 ;
14035 char * kwnames[] = {
14036 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14037 };
14038
14039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14041 if (!SWIG_IsOK(res1)) {
14042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14043 }
14044 arg1 = reinterpret_cast< wxImage * >(argp1);
14045 ecode2 = SWIG_AsVal_int(obj1, &val2);
14046 if (!SWIG_IsOK(ecode2)) {
14047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14048 }
14049 arg2 = static_cast< int >(val2);
14050 ecode3 = SWIG_AsVal_int(obj2, &val3);
14051 if (!SWIG_IsOK(ecode3)) {
14052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14053 }
14054 arg3 = static_cast< int >(val3);
14055 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14056 if (!SWIG_IsOK(ecode4)) {
14057 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14058 }
14059 arg4 = static_cast< byte >(val4);
14060 {
14061 PyThreadState* __tstate = wxPyBeginAllowThreads();
14062 (arg1)->SetAlpha(arg2,arg3,arg4);
14063 wxPyEndAllowThreads(__tstate);
14064 if (PyErr_Occurred()) SWIG_fail;
14065 }
14066 resultobj = SWIG_Py_Void();
14067 return resultobj;
14068 fail:
14069 return NULL;
14070 }
14071
14072
14073 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14074 PyObject *resultobj = 0;
14075 wxImage *arg1 = (wxImage *) 0 ;
14076 int arg2 ;
14077 int arg3 ;
14078 byte result;
14079 void *argp1 = 0 ;
14080 int res1 = 0 ;
14081 int val2 ;
14082 int ecode2 = 0 ;
14083 int val3 ;
14084 int ecode3 = 0 ;
14085 PyObject * obj0 = 0 ;
14086 PyObject * obj1 = 0 ;
14087 PyObject * obj2 = 0 ;
14088 char * kwnames[] = {
14089 (char *) "self",(char *) "x",(char *) "y", NULL
14090 };
14091
14092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14094 if (!SWIG_IsOK(res1)) {
14095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14096 }
14097 arg1 = reinterpret_cast< wxImage * >(argp1);
14098 ecode2 = SWIG_AsVal_int(obj1, &val2);
14099 if (!SWIG_IsOK(ecode2)) {
14100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14101 }
14102 arg2 = static_cast< int >(val2);
14103 ecode3 = SWIG_AsVal_int(obj2, &val3);
14104 if (!SWIG_IsOK(ecode3)) {
14105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14106 }
14107 arg3 = static_cast< int >(val3);
14108 {
14109 PyThreadState* __tstate = wxPyBeginAllowThreads();
14110 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14111 wxPyEndAllowThreads(__tstate);
14112 if (PyErr_Occurred()) SWIG_fail;
14113 }
14114 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14115 return resultobj;
14116 fail:
14117 return NULL;
14118 }
14119
14120
14121 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14122 PyObject *resultobj = 0;
14123 wxImage *arg1 = (wxImage *) 0 ;
14124 bool result;
14125 void *argp1 = 0 ;
14126 int res1 = 0 ;
14127 PyObject *swig_obj[1] ;
14128
14129 if (!args) SWIG_fail;
14130 swig_obj[0] = args;
14131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14132 if (!SWIG_IsOK(res1)) {
14133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14134 }
14135 arg1 = reinterpret_cast< wxImage * >(argp1);
14136 {
14137 PyThreadState* __tstate = wxPyBeginAllowThreads();
14138 result = (bool)(arg1)->HasAlpha();
14139 wxPyEndAllowThreads(__tstate);
14140 if (PyErr_Occurred()) SWIG_fail;
14141 }
14142 {
14143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14144 }
14145 return resultobj;
14146 fail:
14147 return NULL;
14148 }
14149
14150
14151 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14152 PyObject *resultobj = 0;
14153 wxImage *arg1 = (wxImage *) 0 ;
14154 void *argp1 = 0 ;
14155 int res1 = 0 ;
14156 PyObject *swig_obj[1] ;
14157
14158 if (!args) SWIG_fail;
14159 swig_obj[0] = args;
14160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14161 if (!SWIG_IsOK(res1)) {
14162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14163 }
14164 arg1 = reinterpret_cast< wxImage * >(argp1);
14165 {
14166 PyThreadState* __tstate = wxPyBeginAllowThreads();
14167 (arg1)->InitAlpha();
14168 wxPyEndAllowThreads(__tstate);
14169 if (PyErr_Occurred()) SWIG_fail;
14170 }
14171 resultobj = SWIG_Py_Void();
14172 return resultobj;
14173 fail:
14174 return NULL;
14175 }
14176
14177
14178 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14179 PyObject *resultobj = 0;
14180 wxImage *arg1 = (wxImage *) 0 ;
14181 int arg2 ;
14182 int arg3 ;
14183 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14184 bool result;
14185 void *argp1 = 0 ;
14186 int res1 = 0 ;
14187 int val2 ;
14188 int ecode2 = 0 ;
14189 int val3 ;
14190 int ecode3 = 0 ;
14191 unsigned char val4 ;
14192 int ecode4 = 0 ;
14193 PyObject * obj0 = 0 ;
14194 PyObject * obj1 = 0 ;
14195 PyObject * obj2 = 0 ;
14196 PyObject * obj3 = 0 ;
14197 char * kwnames[] = {
14198 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14199 };
14200
14201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14203 if (!SWIG_IsOK(res1)) {
14204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14205 }
14206 arg1 = reinterpret_cast< wxImage * >(argp1);
14207 ecode2 = SWIG_AsVal_int(obj1, &val2);
14208 if (!SWIG_IsOK(ecode2)) {
14209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14210 }
14211 arg2 = static_cast< int >(val2);
14212 ecode3 = SWIG_AsVal_int(obj2, &val3);
14213 if (!SWIG_IsOK(ecode3)) {
14214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14215 }
14216 arg3 = static_cast< int >(val3);
14217 if (obj3) {
14218 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14219 if (!SWIG_IsOK(ecode4)) {
14220 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14221 }
14222 arg4 = static_cast< byte >(val4);
14223 }
14224 {
14225 PyThreadState* __tstate = wxPyBeginAllowThreads();
14226 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14227 wxPyEndAllowThreads(__tstate);
14228 if (PyErr_Occurred()) SWIG_fail;
14229 }
14230 {
14231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14232 }
14233 return resultobj;
14234 fail:
14235 return NULL;
14236 }
14237
14238
14239 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14240 PyObject *resultobj = 0;
14241 wxImage *arg1 = (wxImage *) 0 ;
14242 byte *arg2 = (byte *) 0 ;
14243 byte *arg3 = (byte *) 0 ;
14244 byte *arg4 = (byte *) 0 ;
14245 byte arg5 = (byte) 0 ;
14246 byte arg6 = (byte) 0 ;
14247 byte arg7 = (byte) 0 ;
14248 bool result;
14249 void *argp1 = 0 ;
14250 int res1 = 0 ;
14251 byte temp2 ;
14252 int res2 = SWIG_TMPOBJ ;
14253 byte temp3 ;
14254 int res3 = SWIG_TMPOBJ ;
14255 byte temp4 ;
14256 int res4 = SWIG_TMPOBJ ;
14257 unsigned char val5 ;
14258 int ecode5 = 0 ;
14259 unsigned char val6 ;
14260 int ecode6 = 0 ;
14261 unsigned char val7 ;
14262 int ecode7 = 0 ;
14263 PyObject * obj0 = 0 ;
14264 PyObject * obj1 = 0 ;
14265 PyObject * obj2 = 0 ;
14266 PyObject * obj3 = 0 ;
14267 char * kwnames[] = {
14268 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14269 };
14270
14271 arg2 = &temp2;
14272 arg3 = &temp3;
14273 arg4 = &temp4;
14274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14276 if (!SWIG_IsOK(res1)) {
14277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14278 }
14279 arg1 = reinterpret_cast< wxImage * >(argp1);
14280 if (obj1) {
14281 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14282 if (!SWIG_IsOK(ecode5)) {
14283 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14284 }
14285 arg5 = static_cast< byte >(val5);
14286 }
14287 if (obj2) {
14288 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14289 if (!SWIG_IsOK(ecode6)) {
14290 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14291 }
14292 arg6 = static_cast< byte >(val6);
14293 }
14294 if (obj3) {
14295 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14296 if (!SWIG_IsOK(ecode7)) {
14297 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14298 }
14299 arg7 = static_cast< byte >(val7);
14300 }
14301 {
14302 PyThreadState* __tstate = wxPyBeginAllowThreads();
14303 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14304 wxPyEndAllowThreads(__tstate);
14305 if (PyErr_Occurred()) SWIG_fail;
14306 }
14307 {
14308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14309 }
14310 if (SWIG_IsTmpObj(res2)) {
14311 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14312 } else {
14313 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14314 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14315 }
14316 if (SWIG_IsTmpObj(res3)) {
14317 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14318 } else {
14319 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14320 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14321 }
14322 if (SWIG_IsTmpObj(res4)) {
14323 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14324 } else {
14325 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14326 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14327 }
14328 return resultobj;
14329 fail:
14330 return NULL;
14331 }
14332
14333
14334 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14335 PyObject *resultobj = 0;
14336 wxImage *arg1 = (wxImage *) 0 ;
14337 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14338 bool result;
14339 void *argp1 = 0 ;
14340 int res1 = 0 ;
14341 unsigned char val2 ;
14342 int ecode2 = 0 ;
14343 PyObject * obj0 = 0 ;
14344 PyObject * obj1 = 0 ;
14345 char * kwnames[] = {
14346 (char *) "self",(char *) "threshold", NULL
14347 };
14348
14349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14351 if (!SWIG_IsOK(res1)) {
14352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14353 }
14354 arg1 = reinterpret_cast< wxImage * >(argp1);
14355 if (obj1) {
14356 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14357 if (!SWIG_IsOK(ecode2)) {
14358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14359 }
14360 arg2 = static_cast< byte >(val2);
14361 }
14362 {
14363 PyThreadState* __tstate = wxPyBeginAllowThreads();
14364 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14365 wxPyEndAllowThreads(__tstate);
14366 if (PyErr_Occurred()) SWIG_fail;
14367 }
14368 {
14369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14370 }
14371 return resultobj;
14372 fail:
14373 return NULL;
14374 }
14375
14376
14377 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14378 PyObject *resultobj = 0;
14379 wxImage *arg1 = (wxImage *) 0 ;
14380 byte arg2 ;
14381 byte arg3 ;
14382 byte arg4 ;
14383 bool result;
14384 void *argp1 = 0 ;
14385 int res1 = 0 ;
14386 unsigned char val2 ;
14387 int ecode2 = 0 ;
14388 unsigned char val3 ;
14389 int ecode3 = 0 ;
14390 unsigned char val4 ;
14391 int ecode4 = 0 ;
14392 PyObject * obj0 = 0 ;
14393 PyObject * obj1 = 0 ;
14394 PyObject * obj2 = 0 ;
14395 PyObject * obj3 = 0 ;
14396 char * kwnames[] = {
14397 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14398 };
14399
14400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14402 if (!SWIG_IsOK(res1)) {
14403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14404 }
14405 arg1 = reinterpret_cast< wxImage * >(argp1);
14406 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14407 if (!SWIG_IsOK(ecode2)) {
14408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14409 }
14410 arg2 = static_cast< byte >(val2);
14411 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14412 if (!SWIG_IsOK(ecode3)) {
14413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14414 }
14415 arg3 = static_cast< byte >(val3);
14416 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14417 if (!SWIG_IsOK(ecode4)) {
14418 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14419 }
14420 arg4 = static_cast< byte >(val4);
14421 {
14422 PyThreadState* __tstate = wxPyBeginAllowThreads();
14423 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14424 wxPyEndAllowThreads(__tstate);
14425 if (PyErr_Occurred()) SWIG_fail;
14426 }
14427 {
14428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14429 }
14430 return resultobj;
14431 fail:
14432 return NULL;
14433 }
14434
14435
14436 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14437 PyObject *resultobj = 0;
14438 wxImage *arg1 = (wxImage *) 0 ;
14439 wxImage *arg2 = 0 ;
14440 byte arg3 ;
14441 byte arg4 ;
14442 byte arg5 ;
14443 bool result;
14444 void *argp1 = 0 ;
14445 int res1 = 0 ;
14446 void *argp2 = 0 ;
14447 int res2 = 0 ;
14448 unsigned char val3 ;
14449 int ecode3 = 0 ;
14450 unsigned char val4 ;
14451 int ecode4 = 0 ;
14452 unsigned char val5 ;
14453 int ecode5 = 0 ;
14454 PyObject * obj0 = 0 ;
14455 PyObject * obj1 = 0 ;
14456 PyObject * obj2 = 0 ;
14457 PyObject * obj3 = 0 ;
14458 PyObject * obj4 = 0 ;
14459 char * kwnames[] = {
14460 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14461 };
14462
14463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14465 if (!SWIG_IsOK(res1)) {
14466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14467 }
14468 arg1 = reinterpret_cast< wxImage * >(argp1);
14469 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14470 if (!SWIG_IsOK(res2)) {
14471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14472 }
14473 if (!argp2) {
14474 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14475 }
14476 arg2 = reinterpret_cast< wxImage * >(argp2);
14477 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14478 if (!SWIG_IsOK(ecode3)) {
14479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14480 }
14481 arg3 = static_cast< byte >(val3);
14482 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14483 if (!SWIG_IsOK(ecode4)) {
14484 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14485 }
14486 arg4 = static_cast< byte >(val4);
14487 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14488 if (!SWIG_IsOK(ecode5)) {
14489 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14490 }
14491 arg5 = static_cast< byte >(val5);
14492 {
14493 PyThreadState* __tstate = wxPyBeginAllowThreads();
14494 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14495 wxPyEndAllowThreads(__tstate);
14496 if (PyErr_Occurred()) SWIG_fail;
14497 }
14498 {
14499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14500 }
14501 return resultobj;
14502 fail:
14503 return NULL;
14504 }
14505
14506
14507 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14508 PyObject *resultobj = 0;
14509 wxString *arg1 = 0 ;
14510 bool result;
14511 bool temp1 = false ;
14512 PyObject * obj0 = 0 ;
14513 char * kwnames[] = {
14514 (char *) "filename", NULL
14515 };
14516
14517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14518 {
14519 arg1 = wxString_in_helper(obj0);
14520 if (arg1 == NULL) SWIG_fail;
14521 temp1 = true;
14522 }
14523 {
14524 PyThreadState* __tstate = wxPyBeginAllowThreads();
14525 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14526 wxPyEndAllowThreads(__tstate);
14527 if (PyErr_Occurred()) SWIG_fail;
14528 }
14529 {
14530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14531 }
14532 {
14533 if (temp1)
14534 delete arg1;
14535 }
14536 return resultobj;
14537 fail:
14538 {
14539 if (temp1)
14540 delete arg1;
14541 }
14542 return NULL;
14543 }
14544
14545
14546 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14547 PyObject *resultobj = 0;
14548 wxString *arg1 = 0 ;
14549 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14550 int result;
14551 bool temp1 = false ;
14552 long val2 ;
14553 int ecode2 = 0 ;
14554 PyObject * obj0 = 0 ;
14555 PyObject * obj1 = 0 ;
14556 char * kwnames[] = {
14557 (char *) "filename",(char *) "type", NULL
14558 };
14559
14560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14561 {
14562 arg1 = wxString_in_helper(obj0);
14563 if (arg1 == NULL) SWIG_fail;
14564 temp1 = true;
14565 }
14566 if (obj1) {
14567 ecode2 = SWIG_AsVal_long(obj1, &val2);
14568 if (!SWIG_IsOK(ecode2)) {
14569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14570 }
14571 arg2 = static_cast< long >(val2);
14572 }
14573 {
14574 PyThreadState* __tstate = wxPyBeginAllowThreads();
14575 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14576 wxPyEndAllowThreads(__tstate);
14577 if (PyErr_Occurred()) SWIG_fail;
14578 }
14579 resultobj = SWIG_From_int(static_cast< int >(result));
14580 {
14581 if (temp1)
14582 delete arg1;
14583 }
14584 return resultobj;
14585 fail:
14586 {
14587 if (temp1)
14588 delete arg1;
14589 }
14590 return NULL;
14591 }
14592
14593
14594 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14595 PyObject *resultobj = 0;
14596 wxImage *arg1 = (wxImage *) 0 ;
14597 wxString *arg2 = 0 ;
14598 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14599 int arg4 = (int) -1 ;
14600 bool result;
14601 void *argp1 = 0 ;
14602 int res1 = 0 ;
14603 bool temp2 = false ;
14604 long val3 ;
14605 int ecode3 = 0 ;
14606 int val4 ;
14607 int ecode4 = 0 ;
14608 PyObject * obj0 = 0 ;
14609 PyObject * obj1 = 0 ;
14610 PyObject * obj2 = 0 ;
14611 PyObject * obj3 = 0 ;
14612 char * kwnames[] = {
14613 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14614 };
14615
14616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14618 if (!SWIG_IsOK(res1)) {
14619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14620 }
14621 arg1 = reinterpret_cast< wxImage * >(argp1);
14622 {
14623 arg2 = wxString_in_helper(obj1);
14624 if (arg2 == NULL) SWIG_fail;
14625 temp2 = true;
14626 }
14627 if (obj2) {
14628 ecode3 = SWIG_AsVal_long(obj2, &val3);
14629 if (!SWIG_IsOK(ecode3)) {
14630 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14631 }
14632 arg3 = static_cast< long >(val3);
14633 }
14634 if (obj3) {
14635 ecode4 = SWIG_AsVal_int(obj3, &val4);
14636 if (!SWIG_IsOK(ecode4)) {
14637 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14638 }
14639 arg4 = static_cast< int >(val4);
14640 }
14641 {
14642 PyThreadState* __tstate = wxPyBeginAllowThreads();
14643 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14644 wxPyEndAllowThreads(__tstate);
14645 if (PyErr_Occurred()) SWIG_fail;
14646 }
14647 {
14648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14649 }
14650 {
14651 if (temp2)
14652 delete arg2;
14653 }
14654 return resultobj;
14655 fail:
14656 {
14657 if (temp2)
14658 delete arg2;
14659 }
14660 return NULL;
14661 }
14662
14663
14664 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14665 PyObject *resultobj = 0;
14666 wxImage *arg1 = (wxImage *) 0 ;
14667 wxString *arg2 = 0 ;
14668 wxString *arg3 = 0 ;
14669 int arg4 = (int) -1 ;
14670 bool result;
14671 void *argp1 = 0 ;
14672 int res1 = 0 ;
14673 bool temp2 = false ;
14674 bool temp3 = false ;
14675 int val4 ;
14676 int ecode4 = 0 ;
14677 PyObject * obj0 = 0 ;
14678 PyObject * obj1 = 0 ;
14679 PyObject * obj2 = 0 ;
14680 PyObject * obj3 = 0 ;
14681 char * kwnames[] = {
14682 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14683 };
14684
14685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14687 if (!SWIG_IsOK(res1)) {
14688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14689 }
14690 arg1 = reinterpret_cast< wxImage * >(argp1);
14691 {
14692 arg2 = wxString_in_helper(obj1);
14693 if (arg2 == NULL) SWIG_fail;
14694 temp2 = true;
14695 }
14696 {
14697 arg3 = wxString_in_helper(obj2);
14698 if (arg3 == NULL) SWIG_fail;
14699 temp3 = true;
14700 }
14701 if (obj3) {
14702 ecode4 = SWIG_AsVal_int(obj3, &val4);
14703 if (!SWIG_IsOK(ecode4)) {
14704 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14705 }
14706 arg4 = static_cast< int >(val4);
14707 }
14708 {
14709 PyThreadState* __tstate = wxPyBeginAllowThreads();
14710 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14711 wxPyEndAllowThreads(__tstate);
14712 if (PyErr_Occurred()) SWIG_fail;
14713 }
14714 {
14715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14716 }
14717 {
14718 if (temp2)
14719 delete arg2;
14720 }
14721 {
14722 if (temp3)
14723 delete arg3;
14724 }
14725 return resultobj;
14726 fail:
14727 {
14728 if (temp2)
14729 delete arg2;
14730 }
14731 {
14732 if (temp3)
14733 delete arg3;
14734 }
14735 return NULL;
14736 }
14737
14738
14739 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14740 PyObject *resultobj = 0;
14741 wxImage *arg1 = (wxImage *) 0 ;
14742 wxString *arg2 = 0 ;
14743 int arg3 ;
14744 bool result;
14745 void *argp1 = 0 ;
14746 int res1 = 0 ;
14747 bool temp2 = false ;
14748 int val3 ;
14749 int ecode3 = 0 ;
14750 PyObject * obj0 = 0 ;
14751 PyObject * obj1 = 0 ;
14752 PyObject * obj2 = 0 ;
14753 char * kwnames[] = {
14754 (char *) "self",(char *) "name",(char *) "type", NULL
14755 };
14756
14757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14759 if (!SWIG_IsOK(res1)) {
14760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14761 }
14762 arg1 = reinterpret_cast< wxImage * >(argp1);
14763 {
14764 arg2 = wxString_in_helper(obj1);
14765 if (arg2 == NULL) SWIG_fail;
14766 temp2 = true;
14767 }
14768 ecode3 = SWIG_AsVal_int(obj2, &val3);
14769 if (!SWIG_IsOK(ecode3)) {
14770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14771 }
14772 arg3 = static_cast< int >(val3);
14773 {
14774 PyThreadState* __tstate = wxPyBeginAllowThreads();
14775 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14776 wxPyEndAllowThreads(__tstate);
14777 if (PyErr_Occurred()) SWIG_fail;
14778 }
14779 {
14780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14781 }
14782 {
14783 if (temp2)
14784 delete arg2;
14785 }
14786 return resultobj;
14787 fail:
14788 {
14789 if (temp2)
14790 delete arg2;
14791 }
14792 return NULL;
14793 }
14794
14795
14796 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14797 PyObject *resultobj = 0;
14798 wxImage *arg1 = (wxImage *) 0 ;
14799 wxString *arg2 = 0 ;
14800 wxString *arg3 = 0 ;
14801 bool result;
14802 void *argp1 = 0 ;
14803 int res1 = 0 ;
14804 bool temp2 = false ;
14805 bool temp3 = false ;
14806 PyObject * obj0 = 0 ;
14807 PyObject * obj1 = 0 ;
14808 PyObject * obj2 = 0 ;
14809 char * kwnames[] = {
14810 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14811 };
14812
14813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14815 if (!SWIG_IsOK(res1)) {
14816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14817 }
14818 arg1 = reinterpret_cast< wxImage * >(argp1);
14819 {
14820 arg2 = wxString_in_helper(obj1);
14821 if (arg2 == NULL) SWIG_fail;
14822 temp2 = true;
14823 }
14824 {
14825 arg3 = wxString_in_helper(obj2);
14826 if (arg3 == NULL) SWIG_fail;
14827 temp3 = true;
14828 }
14829 {
14830 PyThreadState* __tstate = wxPyBeginAllowThreads();
14831 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14832 wxPyEndAllowThreads(__tstate);
14833 if (PyErr_Occurred()) SWIG_fail;
14834 }
14835 {
14836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14837 }
14838 {
14839 if (temp2)
14840 delete arg2;
14841 }
14842 {
14843 if (temp3)
14844 delete arg3;
14845 }
14846 return resultobj;
14847 fail:
14848 {
14849 if (temp2)
14850 delete arg2;
14851 }
14852 {
14853 if (temp3)
14854 delete arg3;
14855 }
14856 return NULL;
14857 }
14858
14859
14860 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14861 PyObject *resultobj = 0;
14862 wxInputStream *arg1 = 0 ;
14863 bool result;
14864 wxPyInputStream *temp1 ;
14865 bool created1 ;
14866 PyObject * obj0 = 0 ;
14867 char * kwnames[] = {
14868 (char *) "stream", NULL
14869 };
14870
14871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14872 {
14873 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14874 arg1 = temp1->m_wxis;
14875 created1 = false;
14876 } else {
14877 PyErr_Clear(); // clear the failure of the wxPyConvert above
14878 arg1 = wxPyCBInputStream_create(obj0, false);
14879 if (arg1 == NULL) {
14880 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14881 SWIG_fail;
14882 }
14883 created1 = true;
14884 }
14885 }
14886 {
14887 PyThreadState* __tstate = wxPyBeginAllowThreads();
14888 result = (bool)wxImage::CanRead(*arg1);
14889 wxPyEndAllowThreads(__tstate);
14890 if (PyErr_Occurred()) SWIG_fail;
14891 }
14892 {
14893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14894 }
14895 {
14896 if (created1) delete arg1;
14897 }
14898 return resultobj;
14899 fail:
14900 {
14901 if (created1) delete arg1;
14902 }
14903 return NULL;
14904 }
14905
14906
14907 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14908 PyObject *resultobj = 0;
14909 wxImage *arg1 = (wxImage *) 0 ;
14910 wxInputStream *arg2 = 0 ;
14911 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14912 int arg4 = (int) -1 ;
14913 bool result;
14914 void *argp1 = 0 ;
14915 int res1 = 0 ;
14916 wxPyInputStream *temp2 ;
14917 bool created2 ;
14918 long val3 ;
14919 int ecode3 = 0 ;
14920 int val4 ;
14921 int ecode4 = 0 ;
14922 PyObject * obj0 = 0 ;
14923 PyObject * obj1 = 0 ;
14924 PyObject * obj2 = 0 ;
14925 PyObject * obj3 = 0 ;
14926 char * kwnames[] = {
14927 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14928 };
14929
14930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14932 if (!SWIG_IsOK(res1)) {
14933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14934 }
14935 arg1 = reinterpret_cast< wxImage * >(argp1);
14936 {
14937 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14938 arg2 = temp2->m_wxis;
14939 created2 = false;
14940 } else {
14941 PyErr_Clear(); // clear the failure of the wxPyConvert above
14942 arg2 = wxPyCBInputStream_create(obj1, false);
14943 if (arg2 == NULL) {
14944 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14945 SWIG_fail;
14946 }
14947 created2 = true;
14948 }
14949 }
14950 if (obj2) {
14951 ecode3 = SWIG_AsVal_long(obj2, &val3);
14952 if (!SWIG_IsOK(ecode3)) {
14953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14954 }
14955 arg3 = static_cast< long >(val3);
14956 }
14957 if (obj3) {
14958 ecode4 = SWIG_AsVal_int(obj3, &val4);
14959 if (!SWIG_IsOK(ecode4)) {
14960 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14961 }
14962 arg4 = static_cast< int >(val4);
14963 }
14964 {
14965 PyThreadState* __tstate = wxPyBeginAllowThreads();
14966 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14967 wxPyEndAllowThreads(__tstate);
14968 if (PyErr_Occurred()) SWIG_fail;
14969 }
14970 {
14971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14972 }
14973 {
14974 if (created2) delete arg2;
14975 }
14976 return resultobj;
14977 fail:
14978 {
14979 if (created2) delete arg2;
14980 }
14981 return NULL;
14982 }
14983
14984
14985 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14986 PyObject *resultobj = 0;
14987 wxImage *arg1 = (wxImage *) 0 ;
14988 wxInputStream *arg2 = 0 ;
14989 wxString *arg3 = 0 ;
14990 int arg4 = (int) -1 ;
14991 bool result;
14992 void *argp1 = 0 ;
14993 int res1 = 0 ;
14994 wxPyInputStream *temp2 ;
14995 bool created2 ;
14996 bool temp3 = false ;
14997 int val4 ;
14998 int ecode4 = 0 ;
14999 PyObject * obj0 = 0 ;
15000 PyObject * obj1 = 0 ;
15001 PyObject * obj2 = 0 ;
15002 PyObject * obj3 = 0 ;
15003 char * kwnames[] = {
15004 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15005 };
15006
15007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15009 if (!SWIG_IsOK(res1)) {
15010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15011 }
15012 arg1 = reinterpret_cast< wxImage * >(argp1);
15013 {
15014 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15015 arg2 = temp2->m_wxis;
15016 created2 = false;
15017 } else {
15018 PyErr_Clear(); // clear the failure of the wxPyConvert above
15019 arg2 = wxPyCBInputStream_create(obj1, false);
15020 if (arg2 == NULL) {
15021 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15022 SWIG_fail;
15023 }
15024 created2 = true;
15025 }
15026 }
15027 {
15028 arg3 = wxString_in_helper(obj2);
15029 if (arg3 == NULL) SWIG_fail;
15030 temp3 = true;
15031 }
15032 if (obj3) {
15033 ecode4 = SWIG_AsVal_int(obj3, &val4);
15034 if (!SWIG_IsOK(ecode4)) {
15035 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15036 }
15037 arg4 = static_cast< int >(val4);
15038 }
15039 {
15040 PyThreadState* __tstate = wxPyBeginAllowThreads();
15041 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15042 wxPyEndAllowThreads(__tstate);
15043 if (PyErr_Occurred()) SWIG_fail;
15044 }
15045 {
15046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15047 }
15048 {
15049 if (created2) delete arg2;
15050 }
15051 {
15052 if (temp3)
15053 delete arg3;
15054 }
15055 return resultobj;
15056 fail:
15057 {
15058 if (created2) delete arg2;
15059 }
15060 {
15061 if (temp3)
15062 delete arg3;
15063 }
15064 return NULL;
15065 }
15066
15067
15068 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15069 PyObject *resultobj = 0;
15070 wxImage *arg1 = (wxImage *) 0 ;
15071 bool result;
15072 void *argp1 = 0 ;
15073 int res1 = 0 ;
15074 PyObject *swig_obj[1] ;
15075
15076 if (!args) SWIG_fail;
15077 swig_obj[0] = args;
15078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15079 if (!SWIG_IsOK(res1)) {
15080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15081 }
15082 arg1 = reinterpret_cast< wxImage * >(argp1);
15083 {
15084 PyThreadState* __tstate = wxPyBeginAllowThreads();
15085 result = (bool)(arg1)->Ok();
15086 wxPyEndAllowThreads(__tstate);
15087 if (PyErr_Occurred()) SWIG_fail;
15088 }
15089 {
15090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15091 }
15092 return resultobj;
15093 fail:
15094 return NULL;
15095 }
15096
15097
15098 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15099 PyObject *resultobj = 0;
15100 wxImage *arg1 = (wxImage *) 0 ;
15101 int result;
15102 void *argp1 = 0 ;
15103 int res1 = 0 ;
15104 PyObject *swig_obj[1] ;
15105
15106 if (!args) SWIG_fail;
15107 swig_obj[0] = args;
15108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15109 if (!SWIG_IsOK(res1)) {
15110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15111 }
15112 arg1 = reinterpret_cast< wxImage * >(argp1);
15113 {
15114 PyThreadState* __tstate = wxPyBeginAllowThreads();
15115 result = (int)(arg1)->GetWidth();
15116 wxPyEndAllowThreads(__tstate);
15117 if (PyErr_Occurred()) SWIG_fail;
15118 }
15119 resultobj = SWIG_From_int(static_cast< int >(result));
15120 return resultobj;
15121 fail:
15122 return NULL;
15123 }
15124
15125
15126 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15127 PyObject *resultobj = 0;
15128 wxImage *arg1 = (wxImage *) 0 ;
15129 int result;
15130 void *argp1 = 0 ;
15131 int res1 = 0 ;
15132 PyObject *swig_obj[1] ;
15133
15134 if (!args) SWIG_fail;
15135 swig_obj[0] = args;
15136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15137 if (!SWIG_IsOK(res1)) {
15138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15139 }
15140 arg1 = reinterpret_cast< wxImage * >(argp1);
15141 {
15142 PyThreadState* __tstate = wxPyBeginAllowThreads();
15143 result = (int)(arg1)->GetHeight();
15144 wxPyEndAllowThreads(__tstate);
15145 if (PyErr_Occurred()) SWIG_fail;
15146 }
15147 resultobj = SWIG_From_int(static_cast< int >(result));
15148 return resultobj;
15149 fail:
15150 return NULL;
15151 }
15152
15153
15154 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15155 PyObject *resultobj = 0;
15156 wxImage *arg1 = (wxImage *) 0 ;
15157 wxSize result;
15158 void *argp1 = 0 ;
15159 int res1 = 0 ;
15160 PyObject *swig_obj[1] ;
15161
15162 if (!args) SWIG_fail;
15163 swig_obj[0] = args;
15164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15165 if (!SWIG_IsOK(res1)) {
15166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15167 }
15168 arg1 = reinterpret_cast< wxImage * >(argp1);
15169 {
15170 PyThreadState* __tstate = wxPyBeginAllowThreads();
15171 result = wxImage_GetSize(arg1);
15172 wxPyEndAllowThreads(__tstate);
15173 if (PyErr_Occurred()) SWIG_fail;
15174 }
15175 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15176 return resultobj;
15177 fail:
15178 return NULL;
15179 }
15180
15181
15182 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15183 PyObject *resultobj = 0;
15184 wxImage *arg1 = (wxImage *) 0 ;
15185 wxRect *arg2 = 0 ;
15186 SwigValueWrapper<wxImage > result;
15187 void *argp1 = 0 ;
15188 int res1 = 0 ;
15189 wxRect temp2 ;
15190 PyObject * obj0 = 0 ;
15191 PyObject * obj1 = 0 ;
15192 char * kwnames[] = {
15193 (char *) "self",(char *) "rect", NULL
15194 };
15195
15196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15198 if (!SWIG_IsOK(res1)) {
15199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15200 }
15201 arg1 = reinterpret_cast< wxImage * >(argp1);
15202 {
15203 arg2 = &temp2;
15204 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15205 }
15206 {
15207 PyThreadState* __tstate = wxPyBeginAllowThreads();
15208 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15209 wxPyEndAllowThreads(__tstate);
15210 if (PyErr_Occurred()) SWIG_fail;
15211 }
15212 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15213 return resultobj;
15214 fail:
15215 return NULL;
15216 }
15217
15218
15219 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15220 PyObject *resultobj = 0;
15221 wxImage *arg1 = (wxImage *) 0 ;
15222 wxSize *arg2 = 0 ;
15223 wxPoint *arg3 = 0 ;
15224 int arg4 = (int) -1 ;
15225 int arg5 = (int) -1 ;
15226 int arg6 = (int) -1 ;
15227 SwigValueWrapper<wxImage > result;
15228 void *argp1 = 0 ;
15229 int res1 = 0 ;
15230 wxSize temp2 ;
15231 wxPoint temp3 ;
15232 int val4 ;
15233 int ecode4 = 0 ;
15234 int val5 ;
15235 int ecode5 = 0 ;
15236 int val6 ;
15237 int ecode6 = 0 ;
15238 PyObject * obj0 = 0 ;
15239 PyObject * obj1 = 0 ;
15240 PyObject * obj2 = 0 ;
15241 PyObject * obj3 = 0 ;
15242 PyObject * obj4 = 0 ;
15243 PyObject * obj5 = 0 ;
15244 char * kwnames[] = {
15245 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15246 };
15247
15248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15250 if (!SWIG_IsOK(res1)) {
15251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15252 }
15253 arg1 = reinterpret_cast< wxImage * >(argp1);
15254 {
15255 arg2 = &temp2;
15256 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15257 }
15258 {
15259 arg3 = &temp3;
15260 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15261 }
15262 if (obj3) {
15263 ecode4 = SWIG_AsVal_int(obj3, &val4);
15264 if (!SWIG_IsOK(ecode4)) {
15265 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15266 }
15267 arg4 = static_cast< int >(val4);
15268 }
15269 if (obj4) {
15270 ecode5 = SWIG_AsVal_int(obj4, &val5);
15271 if (!SWIG_IsOK(ecode5)) {
15272 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15273 }
15274 arg5 = static_cast< int >(val5);
15275 }
15276 if (obj5) {
15277 ecode6 = SWIG_AsVal_int(obj5, &val6);
15278 if (!SWIG_IsOK(ecode6)) {
15279 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15280 }
15281 arg6 = static_cast< int >(val6);
15282 }
15283 {
15284 PyThreadState* __tstate = wxPyBeginAllowThreads();
15285 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15286 wxPyEndAllowThreads(__tstate);
15287 if (PyErr_Occurred()) SWIG_fail;
15288 }
15289 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15290 return resultobj;
15291 fail:
15292 return NULL;
15293 }
15294
15295
15296 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15297 PyObject *resultobj = 0;
15298 wxImage *arg1 = (wxImage *) 0 ;
15299 SwigValueWrapper<wxImage > result;
15300 void *argp1 = 0 ;
15301 int res1 = 0 ;
15302 PyObject *swig_obj[1] ;
15303
15304 if (!args) SWIG_fail;
15305 swig_obj[0] = args;
15306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15307 if (!SWIG_IsOK(res1)) {
15308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15309 }
15310 arg1 = reinterpret_cast< wxImage * >(argp1);
15311 {
15312 PyThreadState* __tstate = wxPyBeginAllowThreads();
15313 result = (arg1)->Copy();
15314 wxPyEndAllowThreads(__tstate);
15315 if (PyErr_Occurred()) SWIG_fail;
15316 }
15317 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15318 return resultobj;
15319 fail:
15320 return NULL;
15321 }
15322
15323
15324 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15325 PyObject *resultobj = 0;
15326 wxImage *arg1 = (wxImage *) 0 ;
15327 wxImage *arg2 = 0 ;
15328 int arg3 ;
15329 int arg4 ;
15330 void *argp1 = 0 ;
15331 int res1 = 0 ;
15332 void *argp2 = 0 ;
15333 int res2 = 0 ;
15334 int val3 ;
15335 int ecode3 = 0 ;
15336 int val4 ;
15337 int ecode4 = 0 ;
15338 PyObject * obj0 = 0 ;
15339 PyObject * obj1 = 0 ;
15340 PyObject * obj2 = 0 ;
15341 PyObject * obj3 = 0 ;
15342 char * kwnames[] = {
15343 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15344 };
15345
15346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15348 if (!SWIG_IsOK(res1)) {
15349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15350 }
15351 arg1 = reinterpret_cast< wxImage * >(argp1);
15352 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15353 if (!SWIG_IsOK(res2)) {
15354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15355 }
15356 if (!argp2) {
15357 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15358 }
15359 arg2 = reinterpret_cast< wxImage * >(argp2);
15360 ecode3 = SWIG_AsVal_int(obj2, &val3);
15361 if (!SWIG_IsOK(ecode3)) {
15362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15363 }
15364 arg3 = static_cast< int >(val3);
15365 ecode4 = SWIG_AsVal_int(obj3, &val4);
15366 if (!SWIG_IsOK(ecode4)) {
15367 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15368 }
15369 arg4 = static_cast< int >(val4);
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15373 wxPyEndAllowThreads(__tstate);
15374 if (PyErr_Occurred()) SWIG_fail;
15375 }
15376 resultobj = SWIG_Py_Void();
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15384 PyObject *resultobj = 0;
15385 wxImage *arg1 = (wxImage *) 0 ;
15386 PyObject *result = 0 ;
15387 void *argp1 = 0 ;
15388 int res1 = 0 ;
15389 PyObject *swig_obj[1] ;
15390
15391 if (!args) SWIG_fail;
15392 swig_obj[0] = args;
15393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15394 if (!SWIG_IsOK(res1)) {
15395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15396 }
15397 arg1 = reinterpret_cast< wxImage * >(argp1);
15398 {
15399 PyThreadState* __tstate = wxPyBeginAllowThreads();
15400 result = (PyObject *)wxImage_GetData(arg1);
15401 wxPyEndAllowThreads(__tstate);
15402 if (PyErr_Occurred()) SWIG_fail;
15403 }
15404 resultobj = result;
15405 return resultobj;
15406 fail:
15407 return NULL;
15408 }
15409
15410
15411 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15412 PyObject *resultobj = 0;
15413 wxImage *arg1 = (wxImage *) 0 ;
15414 buffer arg2 ;
15415 int arg3 ;
15416 void *argp1 = 0 ;
15417 int res1 = 0 ;
15418 PyObject * obj0 = 0 ;
15419 PyObject * obj1 = 0 ;
15420 char * kwnames[] = {
15421 (char *) "self",(char *) "data", NULL
15422 };
15423
15424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15426 if (!SWIG_IsOK(res1)) {
15427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15428 }
15429 arg1 = reinterpret_cast< wxImage * >(argp1);
15430 {
15431 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15432 }
15433 {
15434 PyThreadState* __tstate = wxPyBeginAllowThreads();
15435 wxImage_SetData(arg1,arg2,arg3);
15436 wxPyEndAllowThreads(__tstate);
15437 if (PyErr_Occurred()) SWIG_fail;
15438 }
15439 resultobj = SWIG_Py_Void();
15440 return resultobj;
15441 fail:
15442 return NULL;
15443 }
15444
15445
15446 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15447 PyObject *resultobj = 0;
15448 wxImage *arg1 = (wxImage *) 0 ;
15449 PyObject *result = 0 ;
15450 void *argp1 = 0 ;
15451 int res1 = 0 ;
15452 PyObject *swig_obj[1] ;
15453
15454 if (!args) SWIG_fail;
15455 swig_obj[0] = args;
15456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15457 if (!SWIG_IsOK(res1)) {
15458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15459 }
15460 arg1 = reinterpret_cast< wxImage * >(argp1);
15461 {
15462 PyThreadState* __tstate = wxPyBeginAllowThreads();
15463 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15464 wxPyEndAllowThreads(__tstate);
15465 if (PyErr_Occurred()) SWIG_fail;
15466 }
15467 resultobj = result;
15468 return resultobj;
15469 fail:
15470 return NULL;
15471 }
15472
15473
15474 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15475 PyObject *resultobj = 0;
15476 wxImage *arg1 = (wxImage *) 0 ;
15477 buffer arg2 ;
15478 int arg3 ;
15479 void *argp1 = 0 ;
15480 int res1 = 0 ;
15481 PyObject * obj0 = 0 ;
15482 PyObject * obj1 = 0 ;
15483 char * kwnames[] = {
15484 (char *) "self",(char *) "data", NULL
15485 };
15486
15487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15489 if (!SWIG_IsOK(res1)) {
15490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15491 }
15492 arg1 = reinterpret_cast< wxImage * >(argp1);
15493 {
15494 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15495 }
15496 {
15497 PyThreadState* __tstate = wxPyBeginAllowThreads();
15498 wxImage_SetDataBuffer(arg1,arg2,arg3);
15499 wxPyEndAllowThreads(__tstate);
15500 if (PyErr_Occurred()) SWIG_fail;
15501 }
15502 resultobj = SWIG_Py_Void();
15503 return resultobj;
15504 fail:
15505 return NULL;
15506 }
15507
15508
15509 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15510 PyObject *resultobj = 0;
15511 wxImage *arg1 = (wxImage *) 0 ;
15512 PyObject *result = 0 ;
15513 void *argp1 = 0 ;
15514 int res1 = 0 ;
15515 PyObject *swig_obj[1] ;
15516
15517 if (!args) SWIG_fail;
15518 swig_obj[0] = args;
15519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15520 if (!SWIG_IsOK(res1)) {
15521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15522 }
15523 arg1 = reinterpret_cast< wxImage * >(argp1);
15524 {
15525 PyThreadState* __tstate = wxPyBeginAllowThreads();
15526 result = (PyObject *)wxImage_GetAlphaData(arg1);
15527 wxPyEndAllowThreads(__tstate);
15528 if (PyErr_Occurred()) SWIG_fail;
15529 }
15530 resultobj = result;
15531 return resultobj;
15532 fail:
15533 return NULL;
15534 }
15535
15536
15537 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15538 PyObject *resultobj = 0;
15539 wxImage *arg1 = (wxImage *) 0 ;
15540 buffer arg2 ;
15541 int arg3 ;
15542 void *argp1 = 0 ;
15543 int res1 = 0 ;
15544 PyObject * obj0 = 0 ;
15545 PyObject * obj1 = 0 ;
15546 char * kwnames[] = {
15547 (char *) "self",(char *) "alpha", NULL
15548 };
15549
15550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15552 if (!SWIG_IsOK(res1)) {
15553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15554 }
15555 arg1 = reinterpret_cast< wxImage * >(argp1);
15556 {
15557 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15558 }
15559 {
15560 PyThreadState* __tstate = wxPyBeginAllowThreads();
15561 wxImage_SetAlphaData(arg1,arg2,arg3);
15562 wxPyEndAllowThreads(__tstate);
15563 if (PyErr_Occurred()) SWIG_fail;
15564 }
15565 resultobj = SWIG_Py_Void();
15566 return resultobj;
15567 fail:
15568 return NULL;
15569 }
15570
15571
15572 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15573 PyObject *resultobj = 0;
15574 wxImage *arg1 = (wxImage *) 0 ;
15575 PyObject *result = 0 ;
15576 void *argp1 = 0 ;
15577 int res1 = 0 ;
15578 PyObject *swig_obj[1] ;
15579
15580 if (!args) SWIG_fail;
15581 swig_obj[0] = args;
15582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15583 if (!SWIG_IsOK(res1)) {
15584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15585 }
15586 arg1 = reinterpret_cast< wxImage * >(argp1);
15587 {
15588 PyThreadState* __tstate = wxPyBeginAllowThreads();
15589 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15590 wxPyEndAllowThreads(__tstate);
15591 if (PyErr_Occurred()) SWIG_fail;
15592 }
15593 resultobj = result;
15594 return resultobj;
15595 fail:
15596 return NULL;
15597 }
15598
15599
15600 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15601 PyObject *resultobj = 0;
15602 wxImage *arg1 = (wxImage *) 0 ;
15603 buffer arg2 ;
15604 int arg3 ;
15605 void *argp1 = 0 ;
15606 int res1 = 0 ;
15607 PyObject * obj0 = 0 ;
15608 PyObject * obj1 = 0 ;
15609 char * kwnames[] = {
15610 (char *) "self",(char *) "alpha", NULL
15611 };
15612
15613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15615 if (!SWIG_IsOK(res1)) {
15616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15617 }
15618 arg1 = reinterpret_cast< wxImage * >(argp1);
15619 {
15620 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15621 }
15622 {
15623 PyThreadState* __tstate = wxPyBeginAllowThreads();
15624 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15625 wxPyEndAllowThreads(__tstate);
15626 if (PyErr_Occurred()) SWIG_fail;
15627 }
15628 resultobj = SWIG_Py_Void();
15629 return resultobj;
15630 fail:
15631 return NULL;
15632 }
15633
15634
15635 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15636 PyObject *resultobj = 0;
15637 wxImage *arg1 = (wxImage *) 0 ;
15638 byte arg2 ;
15639 byte arg3 ;
15640 byte arg4 ;
15641 void *argp1 = 0 ;
15642 int res1 = 0 ;
15643 unsigned char val2 ;
15644 int ecode2 = 0 ;
15645 unsigned char val3 ;
15646 int ecode3 = 0 ;
15647 unsigned char val4 ;
15648 int ecode4 = 0 ;
15649 PyObject * obj0 = 0 ;
15650 PyObject * obj1 = 0 ;
15651 PyObject * obj2 = 0 ;
15652 PyObject * obj3 = 0 ;
15653 char * kwnames[] = {
15654 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15655 };
15656
15657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15659 if (!SWIG_IsOK(res1)) {
15660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15661 }
15662 arg1 = reinterpret_cast< wxImage * >(argp1);
15663 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15664 if (!SWIG_IsOK(ecode2)) {
15665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15666 }
15667 arg2 = static_cast< byte >(val2);
15668 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15669 if (!SWIG_IsOK(ecode3)) {
15670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15671 }
15672 arg3 = static_cast< byte >(val3);
15673 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15674 if (!SWIG_IsOK(ecode4)) {
15675 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15676 }
15677 arg4 = static_cast< byte >(val4);
15678 {
15679 PyThreadState* __tstate = wxPyBeginAllowThreads();
15680 (arg1)->SetMaskColour(arg2,arg3,arg4);
15681 wxPyEndAllowThreads(__tstate);
15682 if (PyErr_Occurred()) SWIG_fail;
15683 }
15684 resultobj = SWIG_Py_Void();
15685 return resultobj;
15686 fail:
15687 return NULL;
15688 }
15689
15690
15691 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15692 PyObject *resultobj = 0;
15693 wxImage *arg1 = (wxImage *) 0 ;
15694 byte *arg2 = (byte *) 0 ;
15695 byte *arg3 = (byte *) 0 ;
15696 byte *arg4 = (byte *) 0 ;
15697 void *argp1 = 0 ;
15698 int res1 = 0 ;
15699 byte temp2 ;
15700 int res2 = SWIG_TMPOBJ ;
15701 byte temp3 ;
15702 int res3 = SWIG_TMPOBJ ;
15703 byte temp4 ;
15704 int res4 = SWIG_TMPOBJ ;
15705 PyObject *swig_obj[1] ;
15706
15707 arg2 = &temp2;
15708 arg3 = &temp3;
15709 arg4 = &temp4;
15710 if (!args) SWIG_fail;
15711 swig_obj[0] = args;
15712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15713 if (!SWIG_IsOK(res1)) {
15714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15715 }
15716 arg1 = reinterpret_cast< wxImage * >(argp1);
15717 {
15718 PyThreadState* __tstate = wxPyBeginAllowThreads();
15719 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15720 wxPyEndAllowThreads(__tstate);
15721 if (PyErr_Occurred()) SWIG_fail;
15722 }
15723 resultobj = SWIG_Py_Void();
15724 if (SWIG_IsTmpObj(res2)) {
15725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15726 } else {
15727 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15729 }
15730 if (SWIG_IsTmpObj(res3)) {
15731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15732 } else {
15733 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15735 }
15736 if (SWIG_IsTmpObj(res4)) {
15737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15738 } else {
15739 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15741 }
15742 return resultobj;
15743 fail:
15744 return NULL;
15745 }
15746
15747
15748 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15749 PyObject *resultobj = 0;
15750 wxImage *arg1 = (wxImage *) 0 ;
15751 byte result;
15752 void *argp1 = 0 ;
15753 int res1 = 0 ;
15754 PyObject *swig_obj[1] ;
15755
15756 if (!args) SWIG_fail;
15757 swig_obj[0] = args;
15758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15759 if (!SWIG_IsOK(res1)) {
15760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15761 }
15762 arg1 = reinterpret_cast< wxImage * >(argp1);
15763 {
15764 PyThreadState* __tstate = wxPyBeginAllowThreads();
15765 result = (byte)(arg1)->GetMaskRed();
15766 wxPyEndAllowThreads(__tstate);
15767 if (PyErr_Occurred()) SWIG_fail;
15768 }
15769 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15770 return resultobj;
15771 fail:
15772 return NULL;
15773 }
15774
15775
15776 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15777 PyObject *resultobj = 0;
15778 wxImage *arg1 = (wxImage *) 0 ;
15779 byte result;
15780 void *argp1 = 0 ;
15781 int res1 = 0 ;
15782 PyObject *swig_obj[1] ;
15783
15784 if (!args) SWIG_fail;
15785 swig_obj[0] = args;
15786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15787 if (!SWIG_IsOK(res1)) {
15788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15789 }
15790 arg1 = reinterpret_cast< wxImage * >(argp1);
15791 {
15792 PyThreadState* __tstate = wxPyBeginAllowThreads();
15793 result = (byte)(arg1)->GetMaskGreen();
15794 wxPyEndAllowThreads(__tstate);
15795 if (PyErr_Occurred()) SWIG_fail;
15796 }
15797 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15798 return resultobj;
15799 fail:
15800 return NULL;
15801 }
15802
15803
15804 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15805 PyObject *resultobj = 0;
15806 wxImage *arg1 = (wxImage *) 0 ;
15807 byte result;
15808 void *argp1 = 0 ;
15809 int res1 = 0 ;
15810 PyObject *swig_obj[1] ;
15811
15812 if (!args) SWIG_fail;
15813 swig_obj[0] = args;
15814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15815 if (!SWIG_IsOK(res1)) {
15816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15817 }
15818 arg1 = reinterpret_cast< wxImage * >(argp1);
15819 {
15820 PyThreadState* __tstate = wxPyBeginAllowThreads();
15821 result = (byte)(arg1)->GetMaskBlue();
15822 wxPyEndAllowThreads(__tstate);
15823 if (PyErr_Occurred()) SWIG_fail;
15824 }
15825 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15826 return resultobj;
15827 fail:
15828 return NULL;
15829 }
15830
15831
15832 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15833 PyObject *resultobj = 0;
15834 wxImage *arg1 = (wxImage *) 0 ;
15835 bool arg2 = (bool) true ;
15836 void *argp1 = 0 ;
15837 int res1 = 0 ;
15838 bool val2 ;
15839 int ecode2 = 0 ;
15840 PyObject * obj0 = 0 ;
15841 PyObject * obj1 = 0 ;
15842 char * kwnames[] = {
15843 (char *) "self",(char *) "mask", NULL
15844 };
15845
15846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15848 if (!SWIG_IsOK(res1)) {
15849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15850 }
15851 arg1 = reinterpret_cast< wxImage * >(argp1);
15852 if (obj1) {
15853 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15854 if (!SWIG_IsOK(ecode2)) {
15855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15856 }
15857 arg2 = static_cast< bool >(val2);
15858 }
15859 {
15860 PyThreadState* __tstate = wxPyBeginAllowThreads();
15861 (arg1)->SetMask(arg2);
15862 wxPyEndAllowThreads(__tstate);
15863 if (PyErr_Occurred()) SWIG_fail;
15864 }
15865 resultobj = SWIG_Py_Void();
15866 return resultobj;
15867 fail:
15868 return NULL;
15869 }
15870
15871
15872 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15873 PyObject *resultobj = 0;
15874 wxImage *arg1 = (wxImage *) 0 ;
15875 bool result;
15876 void *argp1 = 0 ;
15877 int res1 = 0 ;
15878 PyObject *swig_obj[1] ;
15879
15880 if (!args) SWIG_fail;
15881 swig_obj[0] = args;
15882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15883 if (!SWIG_IsOK(res1)) {
15884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15885 }
15886 arg1 = reinterpret_cast< wxImage * >(argp1);
15887 {
15888 PyThreadState* __tstate = wxPyBeginAllowThreads();
15889 result = (bool)(arg1)->HasMask();
15890 wxPyEndAllowThreads(__tstate);
15891 if (PyErr_Occurred()) SWIG_fail;
15892 }
15893 {
15894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15895 }
15896 return resultobj;
15897 fail:
15898 return NULL;
15899 }
15900
15901
15902 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15903 PyObject *resultobj = 0;
15904 wxImage *arg1 = (wxImage *) 0 ;
15905 double arg2 ;
15906 wxPoint *arg3 = 0 ;
15907 bool arg4 = (bool) true ;
15908 wxPoint *arg5 = (wxPoint *) NULL ;
15909 SwigValueWrapper<wxImage > result;
15910 void *argp1 = 0 ;
15911 int res1 = 0 ;
15912 double val2 ;
15913 int ecode2 = 0 ;
15914 wxPoint temp3 ;
15915 bool val4 ;
15916 int ecode4 = 0 ;
15917 void *argp5 = 0 ;
15918 int res5 = 0 ;
15919 PyObject * obj0 = 0 ;
15920 PyObject * obj1 = 0 ;
15921 PyObject * obj2 = 0 ;
15922 PyObject * obj3 = 0 ;
15923 PyObject * obj4 = 0 ;
15924 char * kwnames[] = {
15925 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15926 };
15927
15928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15930 if (!SWIG_IsOK(res1)) {
15931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15932 }
15933 arg1 = reinterpret_cast< wxImage * >(argp1);
15934 ecode2 = SWIG_AsVal_double(obj1, &val2);
15935 if (!SWIG_IsOK(ecode2)) {
15936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15937 }
15938 arg2 = static_cast< double >(val2);
15939 {
15940 arg3 = &temp3;
15941 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15942 }
15943 if (obj3) {
15944 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15945 if (!SWIG_IsOK(ecode4)) {
15946 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15947 }
15948 arg4 = static_cast< bool >(val4);
15949 }
15950 if (obj4) {
15951 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15952 if (!SWIG_IsOK(res5)) {
15953 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15954 }
15955 arg5 = reinterpret_cast< wxPoint * >(argp5);
15956 }
15957 {
15958 PyThreadState* __tstate = wxPyBeginAllowThreads();
15959 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15960 wxPyEndAllowThreads(__tstate);
15961 if (PyErr_Occurred()) SWIG_fail;
15962 }
15963 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15964 return resultobj;
15965 fail:
15966 return NULL;
15967 }
15968
15969
15970 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15971 PyObject *resultobj = 0;
15972 wxImage *arg1 = (wxImage *) 0 ;
15973 bool arg2 = (bool) true ;
15974 SwigValueWrapper<wxImage > result;
15975 void *argp1 = 0 ;
15976 int res1 = 0 ;
15977 bool val2 ;
15978 int ecode2 = 0 ;
15979 PyObject * obj0 = 0 ;
15980 PyObject * obj1 = 0 ;
15981 char * kwnames[] = {
15982 (char *) "self",(char *) "clockwise", NULL
15983 };
15984
15985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15987 if (!SWIG_IsOK(res1)) {
15988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15989 }
15990 arg1 = reinterpret_cast< wxImage * >(argp1);
15991 if (obj1) {
15992 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15993 if (!SWIG_IsOK(ecode2)) {
15994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15995 }
15996 arg2 = static_cast< bool >(val2);
15997 }
15998 {
15999 PyThreadState* __tstate = wxPyBeginAllowThreads();
16000 result = (arg1)->Rotate90(arg2);
16001 wxPyEndAllowThreads(__tstate);
16002 if (PyErr_Occurred()) SWIG_fail;
16003 }
16004 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16005 return resultobj;
16006 fail:
16007 return NULL;
16008 }
16009
16010
16011 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16012 PyObject *resultobj = 0;
16013 wxImage *arg1 = (wxImage *) 0 ;
16014 bool arg2 = (bool) true ;
16015 SwigValueWrapper<wxImage > result;
16016 void *argp1 = 0 ;
16017 int res1 = 0 ;
16018 bool val2 ;
16019 int ecode2 = 0 ;
16020 PyObject * obj0 = 0 ;
16021 PyObject * obj1 = 0 ;
16022 char * kwnames[] = {
16023 (char *) "self",(char *) "horizontally", NULL
16024 };
16025
16026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16028 if (!SWIG_IsOK(res1)) {
16029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16030 }
16031 arg1 = reinterpret_cast< wxImage * >(argp1);
16032 if (obj1) {
16033 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16034 if (!SWIG_IsOK(ecode2)) {
16035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16036 }
16037 arg2 = static_cast< bool >(val2);
16038 }
16039 {
16040 PyThreadState* __tstate = wxPyBeginAllowThreads();
16041 result = (arg1)->Mirror(arg2);
16042 wxPyEndAllowThreads(__tstate);
16043 if (PyErr_Occurred()) SWIG_fail;
16044 }
16045 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16046 return resultobj;
16047 fail:
16048 return NULL;
16049 }
16050
16051
16052 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16053 PyObject *resultobj = 0;
16054 wxImage *arg1 = (wxImage *) 0 ;
16055 byte arg2 ;
16056 byte arg3 ;
16057 byte arg4 ;
16058 byte arg5 ;
16059 byte arg6 ;
16060 byte arg7 ;
16061 void *argp1 = 0 ;
16062 int res1 = 0 ;
16063 unsigned char val2 ;
16064 int ecode2 = 0 ;
16065 unsigned char val3 ;
16066 int ecode3 = 0 ;
16067 unsigned char val4 ;
16068 int ecode4 = 0 ;
16069 unsigned char val5 ;
16070 int ecode5 = 0 ;
16071 unsigned char val6 ;
16072 int ecode6 = 0 ;
16073 unsigned char val7 ;
16074 int ecode7 = 0 ;
16075 PyObject * obj0 = 0 ;
16076 PyObject * obj1 = 0 ;
16077 PyObject * obj2 = 0 ;
16078 PyObject * obj3 = 0 ;
16079 PyObject * obj4 = 0 ;
16080 PyObject * obj5 = 0 ;
16081 PyObject * obj6 = 0 ;
16082 char * kwnames[] = {
16083 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16084 };
16085
16086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16088 if (!SWIG_IsOK(res1)) {
16089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16090 }
16091 arg1 = reinterpret_cast< wxImage * >(argp1);
16092 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16093 if (!SWIG_IsOK(ecode2)) {
16094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16095 }
16096 arg2 = static_cast< byte >(val2);
16097 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16098 if (!SWIG_IsOK(ecode3)) {
16099 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16100 }
16101 arg3 = static_cast< byte >(val3);
16102 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16103 if (!SWIG_IsOK(ecode4)) {
16104 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16105 }
16106 arg4 = static_cast< byte >(val4);
16107 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16108 if (!SWIG_IsOK(ecode5)) {
16109 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16110 }
16111 arg5 = static_cast< byte >(val5);
16112 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16113 if (!SWIG_IsOK(ecode6)) {
16114 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16115 }
16116 arg6 = static_cast< byte >(val6);
16117 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16118 if (!SWIG_IsOK(ecode7)) {
16119 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16120 }
16121 arg7 = static_cast< byte >(val7);
16122 {
16123 PyThreadState* __tstate = wxPyBeginAllowThreads();
16124 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16125 wxPyEndAllowThreads(__tstate);
16126 if (PyErr_Occurred()) SWIG_fail;
16127 }
16128 resultobj = SWIG_Py_Void();
16129 return resultobj;
16130 fail:
16131 return NULL;
16132 }
16133
16134
16135 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16136 PyObject *resultobj = 0;
16137 wxImage *arg1 = (wxImage *) 0 ;
16138 double arg2 = (double) 0.299 ;
16139 double arg3 = (double) 0.587 ;
16140 double arg4 = (double) 0.114 ;
16141 SwigValueWrapper<wxImage > result;
16142 void *argp1 = 0 ;
16143 int res1 = 0 ;
16144 double val2 ;
16145 int ecode2 = 0 ;
16146 double val3 ;
16147 int ecode3 = 0 ;
16148 double val4 ;
16149 int ecode4 = 0 ;
16150 PyObject * obj0 = 0 ;
16151 PyObject * obj1 = 0 ;
16152 PyObject * obj2 = 0 ;
16153 PyObject * obj3 = 0 ;
16154 char * kwnames[] = {
16155 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16156 };
16157
16158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16160 if (!SWIG_IsOK(res1)) {
16161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16162 }
16163 arg1 = reinterpret_cast< wxImage * >(argp1);
16164 if (obj1) {
16165 ecode2 = SWIG_AsVal_double(obj1, &val2);
16166 if (!SWIG_IsOK(ecode2)) {
16167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16168 }
16169 arg2 = static_cast< double >(val2);
16170 }
16171 if (obj2) {
16172 ecode3 = SWIG_AsVal_double(obj2, &val3);
16173 if (!SWIG_IsOK(ecode3)) {
16174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16175 }
16176 arg3 = static_cast< double >(val3);
16177 }
16178 if (obj3) {
16179 ecode4 = SWIG_AsVal_double(obj3, &val4);
16180 if (!SWIG_IsOK(ecode4)) {
16181 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16182 }
16183 arg4 = static_cast< double >(val4);
16184 }
16185 {
16186 PyThreadState* __tstate = wxPyBeginAllowThreads();
16187 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16188 wxPyEndAllowThreads(__tstate);
16189 if (PyErr_Occurred()) SWIG_fail;
16190 }
16191 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16192 return resultobj;
16193 fail:
16194 return NULL;
16195 }
16196
16197
16198 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16199 PyObject *resultobj = 0;
16200 wxImage *arg1 = (wxImage *) 0 ;
16201 byte arg2 ;
16202 byte arg3 ;
16203 byte arg4 ;
16204 SwigValueWrapper<wxImage > result;
16205 void *argp1 = 0 ;
16206 int res1 = 0 ;
16207 unsigned char val2 ;
16208 int ecode2 = 0 ;
16209 unsigned char val3 ;
16210 int ecode3 = 0 ;
16211 unsigned char val4 ;
16212 int ecode4 = 0 ;
16213 PyObject * obj0 = 0 ;
16214 PyObject * obj1 = 0 ;
16215 PyObject * obj2 = 0 ;
16216 PyObject * obj3 = 0 ;
16217 char * kwnames[] = {
16218 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16219 };
16220
16221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16223 if (!SWIG_IsOK(res1)) {
16224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16225 }
16226 arg1 = reinterpret_cast< wxImage * >(argp1);
16227 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16228 if (!SWIG_IsOK(ecode2)) {
16229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16230 }
16231 arg2 = static_cast< byte >(val2);
16232 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16233 if (!SWIG_IsOK(ecode3)) {
16234 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16235 }
16236 arg3 = static_cast< byte >(val3);
16237 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16238 if (!SWIG_IsOK(ecode4)) {
16239 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16240 }
16241 arg4 = static_cast< byte >(val4);
16242 {
16243 PyThreadState* __tstate = wxPyBeginAllowThreads();
16244 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16245 wxPyEndAllowThreads(__tstate);
16246 if (PyErr_Occurred()) SWIG_fail;
16247 }
16248 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16249 return resultobj;
16250 fail:
16251 return NULL;
16252 }
16253
16254
16255 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16256 PyObject *resultobj = 0;
16257 wxImage *arg1 = (wxImage *) 0 ;
16258 wxString *arg2 = 0 ;
16259 wxString *arg3 = 0 ;
16260 void *argp1 = 0 ;
16261 int res1 = 0 ;
16262 bool temp2 = false ;
16263 bool temp3 = false ;
16264 PyObject * obj0 = 0 ;
16265 PyObject * obj1 = 0 ;
16266 PyObject * obj2 = 0 ;
16267 char * kwnames[] = {
16268 (char *) "self",(char *) "name",(char *) "value", NULL
16269 };
16270
16271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16273 if (!SWIG_IsOK(res1)) {
16274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16275 }
16276 arg1 = reinterpret_cast< wxImage * >(argp1);
16277 {
16278 arg2 = wxString_in_helper(obj1);
16279 if (arg2 == NULL) SWIG_fail;
16280 temp2 = true;
16281 }
16282 {
16283 arg3 = wxString_in_helper(obj2);
16284 if (arg3 == NULL) SWIG_fail;
16285 temp3 = true;
16286 }
16287 {
16288 PyThreadState* __tstate = wxPyBeginAllowThreads();
16289 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16290 wxPyEndAllowThreads(__tstate);
16291 if (PyErr_Occurred()) SWIG_fail;
16292 }
16293 resultobj = SWIG_Py_Void();
16294 {
16295 if (temp2)
16296 delete arg2;
16297 }
16298 {
16299 if (temp3)
16300 delete arg3;
16301 }
16302 return resultobj;
16303 fail:
16304 {
16305 if (temp2)
16306 delete arg2;
16307 }
16308 {
16309 if (temp3)
16310 delete arg3;
16311 }
16312 return NULL;
16313 }
16314
16315
16316 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16317 PyObject *resultobj = 0;
16318 wxImage *arg1 = (wxImage *) 0 ;
16319 wxString *arg2 = 0 ;
16320 int arg3 ;
16321 void *argp1 = 0 ;
16322 int res1 = 0 ;
16323 bool temp2 = false ;
16324 int val3 ;
16325 int ecode3 = 0 ;
16326 PyObject * obj0 = 0 ;
16327 PyObject * obj1 = 0 ;
16328 PyObject * obj2 = 0 ;
16329 char * kwnames[] = {
16330 (char *) "self",(char *) "name",(char *) "value", NULL
16331 };
16332
16333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16335 if (!SWIG_IsOK(res1)) {
16336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16337 }
16338 arg1 = reinterpret_cast< wxImage * >(argp1);
16339 {
16340 arg2 = wxString_in_helper(obj1);
16341 if (arg2 == NULL) SWIG_fail;
16342 temp2 = true;
16343 }
16344 ecode3 = SWIG_AsVal_int(obj2, &val3);
16345 if (!SWIG_IsOK(ecode3)) {
16346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16347 }
16348 arg3 = static_cast< int >(val3);
16349 {
16350 PyThreadState* __tstate = wxPyBeginAllowThreads();
16351 (arg1)->SetOption((wxString const &)*arg2,arg3);
16352 wxPyEndAllowThreads(__tstate);
16353 if (PyErr_Occurred()) SWIG_fail;
16354 }
16355 resultobj = SWIG_Py_Void();
16356 {
16357 if (temp2)
16358 delete arg2;
16359 }
16360 return resultobj;
16361 fail:
16362 {
16363 if (temp2)
16364 delete arg2;
16365 }
16366 return NULL;
16367 }
16368
16369
16370 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16371 PyObject *resultobj = 0;
16372 wxImage *arg1 = (wxImage *) 0 ;
16373 wxString *arg2 = 0 ;
16374 wxString result;
16375 void *argp1 = 0 ;
16376 int res1 = 0 ;
16377 bool temp2 = false ;
16378 PyObject * obj0 = 0 ;
16379 PyObject * obj1 = 0 ;
16380 char * kwnames[] = {
16381 (char *) "self",(char *) "name", NULL
16382 };
16383
16384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16386 if (!SWIG_IsOK(res1)) {
16387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16388 }
16389 arg1 = reinterpret_cast< wxImage * >(argp1);
16390 {
16391 arg2 = wxString_in_helper(obj1);
16392 if (arg2 == NULL) SWIG_fail;
16393 temp2 = true;
16394 }
16395 {
16396 PyThreadState* __tstate = wxPyBeginAllowThreads();
16397 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16398 wxPyEndAllowThreads(__tstate);
16399 if (PyErr_Occurred()) SWIG_fail;
16400 }
16401 {
16402 #if wxUSE_UNICODE
16403 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16404 #else
16405 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16406 #endif
16407 }
16408 {
16409 if (temp2)
16410 delete arg2;
16411 }
16412 return resultobj;
16413 fail:
16414 {
16415 if (temp2)
16416 delete arg2;
16417 }
16418 return NULL;
16419 }
16420
16421
16422 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16423 PyObject *resultobj = 0;
16424 wxImage *arg1 = (wxImage *) 0 ;
16425 wxString *arg2 = 0 ;
16426 int result;
16427 void *argp1 = 0 ;
16428 int res1 = 0 ;
16429 bool temp2 = false ;
16430 PyObject * obj0 = 0 ;
16431 PyObject * obj1 = 0 ;
16432 char * kwnames[] = {
16433 (char *) "self",(char *) "name", NULL
16434 };
16435
16436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16438 if (!SWIG_IsOK(res1)) {
16439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16440 }
16441 arg1 = reinterpret_cast< wxImage * >(argp1);
16442 {
16443 arg2 = wxString_in_helper(obj1);
16444 if (arg2 == NULL) SWIG_fail;
16445 temp2 = true;
16446 }
16447 {
16448 PyThreadState* __tstate = wxPyBeginAllowThreads();
16449 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16450 wxPyEndAllowThreads(__tstate);
16451 if (PyErr_Occurred()) SWIG_fail;
16452 }
16453 resultobj = SWIG_From_int(static_cast< int >(result));
16454 {
16455 if (temp2)
16456 delete arg2;
16457 }
16458 return resultobj;
16459 fail:
16460 {
16461 if (temp2)
16462 delete arg2;
16463 }
16464 return NULL;
16465 }
16466
16467
16468 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16469 PyObject *resultobj = 0;
16470 wxImage *arg1 = (wxImage *) 0 ;
16471 wxString *arg2 = 0 ;
16472 bool result;
16473 void *argp1 = 0 ;
16474 int res1 = 0 ;
16475 bool temp2 = false ;
16476 PyObject * obj0 = 0 ;
16477 PyObject * obj1 = 0 ;
16478 char * kwnames[] = {
16479 (char *) "self",(char *) "name", NULL
16480 };
16481
16482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16484 if (!SWIG_IsOK(res1)) {
16485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16486 }
16487 arg1 = reinterpret_cast< wxImage * >(argp1);
16488 {
16489 arg2 = wxString_in_helper(obj1);
16490 if (arg2 == NULL) SWIG_fail;
16491 temp2 = true;
16492 }
16493 {
16494 PyThreadState* __tstate = wxPyBeginAllowThreads();
16495 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16496 wxPyEndAllowThreads(__tstate);
16497 if (PyErr_Occurred()) SWIG_fail;
16498 }
16499 {
16500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16501 }
16502 {
16503 if (temp2)
16504 delete arg2;
16505 }
16506 return resultobj;
16507 fail:
16508 {
16509 if (temp2)
16510 delete arg2;
16511 }
16512 return NULL;
16513 }
16514
16515
16516 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16517 PyObject *resultobj = 0;
16518 wxImage *arg1 = (wxImage *) 0 ;
16519 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16520 unsigned long result;
16521 void *argp1 = 0 ;
16522 int res1 = 0 ;
16523 unsigned long val2 ;
16524 int ecode2 = 0 ;
16525 PyObject * obj0 = 0 ;
16526 PyObject * obj1 = 0 ;
16527 char * kwnames[] = {
16528 (char *) "self",(char *) "stopafter", NULL
16529 };
16530
16531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16533 if (!SWIG_IsOK(res1)) {
16534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16535 }
16536 arg1 = reinterpret_cast< wxImage * >(argp1);
16537 if (obj1) {
16538 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16539 if (!SWIG_IsOK(ecode2)) {
16540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16541 }
16542 arg2 = static_cast< unsigned long >(val2);
16543 }
16544 {
16545 PyThreadState* __tstate = wxPyBeginAllowThreads();
16546 result = (unsigned long)(arg1)->CountColours(arg2);
16547 wxPyEndAllowThreads(__tstate);
16548 if (PyErr_Occurred()) SWIG_fail;
16549 }
16550 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16551 return resultobj;
16552 fail:
16553 return NULL;
16554 }
16555
16556
16557 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16558 PyObject *resultobj = 0;
16559 wxImage *arg1 = (wxImage *) 0 ;
16560 wxImageHistogram *arg2 = 0 ;
16561 unsigned long result;
16562 void *argp1 = 0 ;
16563 int res1 = 0 ;
16564 void *argp2 = 0 ;
16565 int res2 = 0 ;
16566 PyObject * obj0 = 0 ;
16567 PyObject * obj1 = 0 ;
16568 char * kwnames[] = {
16569 (char *) "self",(char *) "h", NULL
16570 };
16571
16572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16574 if (!SWIG_IsOK(res1)) {
16575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16576 }
16577 arg1 = reinterpret_cast< wxImage * >(argp1);
16578 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16579 if (!SWIG_IsOK(res2)) {
16580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16581 }
16582 if (!argp2) {
16583 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16584 }
16585 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16586 {
16587 PyThreadState* __tstate = wxPyBeginAllowThreads();
16588 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16589 wxPyEndAllowThreads(__tstate);
16590 if (PyErr_Occurred()) SWIG_fail;
16591 }
16592 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16593 return resultobj;
16594 fail:
16595 return NULL;
16596 }
16597
16598
16599 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16600 PyObject *resultobj = 0;
16601 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16602 void *argp1 = 0 ;
16603 int res1 = 0 ;
16604 PyObject * obj0 = 0 ;
16605 char * kwnames[] = {
16606 (char *) "handler", NULL
16607 };
16608
16609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16611 if (!SWIG_IsOK(res1)) {
16612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16613 }
16614 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16615 {
16616 PyThreadState* __tstate = wxPyBeginAllowThreads();
16617 wxImage::AddHandler(arg1);
16618 wxPyEndAllowThreads(__tstate);
16619 if (PyErr_Occurred()) SWIG_fail;
16620 }
16621 resultobj = SWIG_Py_Void();
16622 return resultobj;
16623 fail:
16624 return NULL;
16625 }
16626
16627
16628 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16629 PyObject *resultobj = 0;
16630 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16631 void *argp1 = 0 ;
16632 int res1 = 0 ;
16633 PyObject * obj0 = 0 ;
16634 char * kwnames[] = {
16635 (char *) "handler", NULL
16636 };
16637
16638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16640 if (!SWIG_IsOK(res1)) {
16641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16642 }
16643 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16644 {
16645 PyThreadState* __tstate = wxPyBeginAllowThreads();
16646 wxImage::InsertHandler(arg1);
16647 wxPyEndAllowThreads(__tstate);
16648 if (PyErr_Occurred()) SWIG_fail;
16649 }
16650 resultobj = SWIG_Py_Void();
16651 return resultobj;
16652 fail:
16653 return NULL;
16654 }
16655
16656
16657 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16658 PyObject *resultobj = 0;
16659 wxString *arg1 = 0 ;
16660 bool result;
16661 bool temp1 = false ;
16662 PyObject * obj0 = 0 ;
16663 char * kwnames[] = {
16664 (char *) "name", NULL
16665 };
16666
16667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16668 {
16669 arg1 = wxString_in_helper(obj0);
16670 if (arg1 == NULL) SWIG_fail;
16671 temp1 = true;
16672 }
16673 {
16674 PyThreadState* __tstate = wxPyBeginAllowThreads();
16675 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16676 wxPyEndAllowThreads(__tstate);
16677 if (PyErr_Occurred()) SWIG_fail;
16678 }
16679 {
16680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16681 }
16682 {
16683 if (temp1)
16684 delete arg1;
16685 }
16686 return resultobj;
16687 fail:
16688 {
16689 if (temp1)
16690 delete arg1;
16691 }
16692 return NULL;
16693 }
16694
16695
16696 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16697 PyObject *resultobj = 0;
16698 PyObject *result = 0 ;
16699
16700 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16701 {
16702 PyThreadState* __tstate = wxPyBeginAllowThreads();
16703 result = (PyObject *)wxImage_GetHandlers();
16704 wxPyEndAllowThreads(__tstate);
16705 if (PyErr_Occurred()) SWIG_fail;
16706 }
16707 resultobj = result;
16708 return resultobj;
16709 fail:
16710 return NULL;
16711 }
16712
16713
16714 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16715 PyObject *resultobj = 0;
16716 wxString result;
16717
16718 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16719 {
16720 PyThreadState* __tstate = wxPyBeginAllowThreads();
16721 result = wxImage::GetImageExtWildcard();
16722 wxPyEndAllowThreads(__tstate);
16723 if (PyErr_Occurred()) SWIG_fail;
16724 }
16725 {
16726 #if wxUSE_UNICODE
16727 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16728 #else
16729 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16730 #endif
16731 }
16732 return resultobj;
16733 fail:
16734 return NULL;
16735 }
16736
16737
16738 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16739 PyObject *resultobj = 0;
16740 wxImage *arg1 = (wxImage *) 0 ;
16741 int arg2 = (int) -1 ;
16742 wxBitmap result;
16743 void *argp1 = 0 ;
16744 int res1 = 0 ;
16745 int val2 ;
16746 int ecode2 = 0 ;
16747 PyObject * obj0 = 0 ;
16748 PyObject * obj1 = 0 ;
16749 char * kwnames[] = {
16750 (char *) "self",(char *) "depth", NULL
16751 };
16752
16753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16755 if (!SWIG_IsOK(res1)) {
16756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16757 }
16758 arg1 = reinterpret_cast< wxImage * >(argp1);
16759 if (obj1) {
16760 ecode2 = SWIG_AsVal_int(obj1, &val2);
16761 if (!SWIG_IsOK(ecode2)) {
16762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16763 }
16764 arg2 = static_cast< int >(val2);
16765 }
16766 {
16767 if (!wxPyCheckForApp()) SWIG_fail;
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 result = wxImage_ConvertToBitmap(arg1,arg2);
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj = 0;
16782 wxImage *arg1 = (wxImage *) 0 ;
16783 byte arg2 ;
16784 byte arg3 ;
16785 byte arg4 ;
16786 wxBitmap result;
16787 void *argp1 = 0 ;
16788 int res1 = 0 ;
16789 unsigned char val2 ;
16790 int ecode2 = 0 ;
16791 unsigned char val3 ;
16792 int ecode3 = 0 ;
16793 unsigned char val4 ;
16794 int ecode4 = 0 ;
16795 PyObject * obj0 = 0 ;
16796 PyObject * obj1 = 0 ;
16797 PyObject * obj2 = 0 ;
16798 PyObject * obj3 = 0 ;
16799 char * kwnames[] = {
16800 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16801 };
16802
16803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16805 if (!SWIG_IsOK(res1)) {
16806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16807 }
16808 arg1 = reinterpret_cast< wxImage * >(argp1);
16809 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16810 if (!SWIG_IsOK(ecode2)) {
16811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16812 }
16813 arg2 = static_cast< byte >(val2);
16814 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16815 if (!SWIG_IsOK(ecode3)) {
16816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16817 }
16818 arg3 = static_cast< byte >(val3);
16819 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16820 if (!SWIG_IsOK(ecode4)) {
16821 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16822 }
16823 arg4 = static_cast< byte >(val4);
16824 {
16825 if (!wxPyCheckForApp()) SWIG_fail;
16826 PyThreadState* __tstate = wxPyBeginAllowThreads();
16827 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16828 wxPyEndAllowThreads(__tstate);
16829 if (PyErr_Occurred()) SWIG_fail;
16830 }
16831 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16832 return resultobj;
16833 fail:
16834 return NULL;
16835 }
16836
16837
16838 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16839 PyObject *resultobj = 0;
16840 wxImage *arg1 = (wxImage *) 0 ;
16841 double arg2 ;
16842 void *argp1 = 0 ;
16843 int res1 = 0 ;
16844 double val2 ;
16845 int ecode2 = 0 ;
16846 PyObject * obj0 = 0 ;
16847 PyObject * obj1 = 0 ;
16848 char * kwnames[] = {
16849 (char *) "self",(char *) "angle", NULL
16850 };
16851
16852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16854 if (!SWIG_IsOK(res1)) {
16855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16856 }
16857 arg1 = reinterpret_cast< wxImage * >(argp1);
16858 ecode2 = SWIG_AsVal_double(obj1, &val2);
16859 if (!SWIG_IsOK(ecode2)) {
16860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16861 }
16862 arg2 = static_cast< double >(val2);
16863 {
16864 PyThreadState* __tstate = wxPyBeginAllowThreads();
16865 (arg1)->RotateHue(arg2);
16866 wxPyEndAllowThreads(__tstate);
16867 if (PyErr_Occurred()) SWIG_fail;
16868 }
16869 resultobj = SWIG_Py_Void();
16870 return resultobj;
16871 fail:
16872 return NULL;
16873 }
16874
16875
16876 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16877 PyObject *resultobj = 0;
16878 wxImage_RGBValue arg1 ;
16879 wxImage_HSVValue result;
16880 void *argp1 ;
16881 int res1 = 0 ;
16882 PyObject * obj0 = 0 ;
16883 char * kwnames[] = {
16884 (char *) "rgb", NULL
16885 };
16886
16887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16888 {
16889 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16890 if (!SWIG_IsOK(res1)) {
16891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16892 }
16893 if (!argp1) {
16894 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16895 } else {
16896 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16897 arg1 = *temp;
16898 if (SWIG_IsNewObj(res1)) delete temp;
16899 }
16900 }
16901 {
16902 PyThreadState* __tstate = wxPyBeginAllowThreads();
16903 result = wxImage::RGBtoHSV(arg1);
16904 wxPyEndAllowThreads(__tstate);
16905 if (PyErr_Occurred()) SWIG_fail;
16906 }
16907 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16908 return resultobj;
16909 fail:
16910 return NULL;
16911 }
16912
16913
16914 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16915 PyObject *resultobj = 0;
16916 wxImage_HSVValue arg1 ;
16917 wxImage_RGBValue result;
16918 void *argp1 ;
16919 int res1 = 0 ;
16920 PyObject * obj0 = 0 ;
16921 char * kwnames[] = {
16922 (char *) "hsv", NULL
16923 };
16924
16925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16926 {
16927 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16928 if (!SWIG_IsOK(res1)) {
16929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16930 }
16931 if (!argp1) {
16932 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16933 } else {
16934 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16935 arg1 = *temp;
16936 if (SWIG_IsNewObj(res1)) delete temp;
16937 }
16938 }
16939 {
16940 PyThreadState* __tstate = wxPyBeginAllowThreads();
16941 result = wxImage::HSVtoRGB(arg1);
16942 wxPyEndAllowThreads(__tstate);
16943 if (PyErr_Occurred()) SWIG_fail;
16944 }
16945 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16946 return resultobj;
16947 fail:
16948 return NULL;
16949 }
16950
16951
16952 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16953 PyObject *obj;
16954 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16955 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16956 return SWIG_Py_Void();
16957 }
16958
16959 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16960 return SWIG_Python_InitShadowInstance(args);
16961 }
16962
16963 SWIGINTERN int NullImage_set(PyObject *) {
16964 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16965 return 1;
16966 }
16967
16968
16969 SWIGINTERN PyObject *NullImage_get(void) {
16970 PyObject *pyobj = 0;
16971
16972 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16973 return pyobj;
16974 }
16975
16976
16977 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16978 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16979 return 1;
16980 }
16981
16982
16983 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16984 PyObject *pyobj = 0;
16985
16986 {
16987 #if wxUSE_UNICODE
16988 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16989 #else
16990 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16991 #endif
16992 }
16993 return pyobj;
16994 }
16995
16996
16997 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16998 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16999 return 1;
17000 }
17001
17002
17003 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17004 PyObject *pyobj = 0;
17005
17006 {
17007 #if wxUSE_UNICODE
17008 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17009 #else
17010 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17011 #endif
17012 }
17013 return pyobj;
17014 }
17015
17016
17017 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17018 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17019 return 1;
17020 }
17021
17022
17023 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17024 PyObject *pyobj = 0;
17025
17026 {
17027 #if wxUSE_UNICODE
17028 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17029 #else
17030 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17031 #endif
17032 }
17033 return pyobj;
17034 }
17035
17036
17037 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17038 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17039 return 1;
17040 }
17041
17042
17043 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17044 PyObject *pyobj = 0;
17045
17046 {
17047 #if wxUSE_UNICODE
17048 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17049 #else
17050 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17051 #endif
17052 }
17053 return pyobj;
17054 }
17055
17056
17057 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17058 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17059 return 1;
17060 }
17061
17062
17063 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17064 PyObject *pyobj = 0;
17065
17066 {
17067 #if wxUSE_UNICODE
17068 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17069 #else
17070 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17071 #endif
17072 }
17073 return pyobj;
17074 }
17075
17076
17077 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17078 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17079 return 1;
17080 }
17081
17082
17083 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17084 PyObject *pyobj = 0;
17085
17086 {
17087 #if wxUSE_UNICODE
17088 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17089 #else
17090 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17091 #endif
17092 }
17093 return pyobj;
17094 }
17095
17096
17097 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17098 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17099 return 1;
17100 }
17101
17102
17103 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17104 PyObject *pyobj = 0;
17105
17106 {
17107 #if wxUSE_UNICODE
17108 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17109 #else
17110 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17111 #endif
17112 }
17113 return pyobj;
17114 }
17115
17116
17117 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17118 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17119 return 1;
17120 }
17121
17122
17123 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17124 PyObject *pyobj = 0;
17125
17126 {
17127 #if wxUSE_UNICODE
17128 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17129 #else
17130 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17131 #endif
17132 }
17133 return pyobj;
17134 }
17135
17136
17137 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17138 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17139 return 1;
17140 }
17141
17142
17143 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17144 PyObject *pyobj = 0;
17145
17146 {
17147 #if wxUSE_UNICODE
17148 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17149 #else
17150 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17151 #endif
17152 }
17153 return pyobj;
17154 }
17155
17156
17157 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17158 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17159 return 1;
17160 }
17161
17162
17163 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17164 PyObject *pyobj = 0;
17165
17166 {
17167 #if wxUSE_UNICODE
17168 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17169 #else
17170 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17171 #endif
17172 }
17173 return pyobj;
17174 }
17175
17176
17177 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17178 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17179 return 1;
17180 }
17181
17182
17183 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17184 PyObject *pyobj = 0;
17185
17186 {
17187 #if wxUSE_UNICODE
17188 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17189 #else
17190 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17191 #endif
17192 }
17193 return pyobj;
17194 }
17195
17196
17197 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17198 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17199 return 1;
17200 }
17201
17202
17203 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17204 PyObject *pyobj = 0;
17205
17206 {
17207 #if wxUSE_UNICODE
17208 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17209 #else
17210 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17211 #endif
17212 }
17213 return pyobj;
17214 }
17215
17216
17217 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17218 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17219 return 1;
17220 }
17221
17222
17223 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17224 PyObject *pyobj = 0;
17225
17226 {
17227 #if wxUSE_UNICODE
17228 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17229 #else
17230 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17231 #endif
17232 }
17233 return pyobj;
17234 }
17235
17236
17237 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17238 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17239 return 1;
17240 }
17241
17242
17243 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17244 PyObject *pyobj = 0;
17245
17246 {
17247 #if wxUSE_UNICODE
17248 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17249 #else
17250 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17251 #endif
17252 }
17253 return pyobj;
17254 }
17255
17256
17257 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17258 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17259 return 1;
17260 }
17261
17262
17263 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17264 PyObject *pyobj = 0;
17265
17266 {
17267 #if wxUSE_UNICODE
17268 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17269 #else
17270 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17271 #endif
17272 }
17273 return pyobj;
17274 }
17275
17276
17277 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17278 PyObject *resultobj = 0;
17279 wxBMPHandler *result = 0 ;
17280
17281 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17282 {
17283 PyThreadState* __tstate = wxPyBeginAllowThreads();
17284 result = (wxBMPHandler *)new wxBMPHandler();
17285 wxPyEndAllowThreads(__tstate);
17286 if (PyErr_Occurred()) SWIG_fail;
17287 }
17288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17289 return resultobj;
17290 fail:
17291 return NULL;
17292 }
17293
17294
17295 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17296 PyObject *obj;
17297 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17298 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17299 return SWIG_Py_Void();
17300 }
17301
17302 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17303 return SWIG_Python_InitShadowInstance(args);
17304 }
17305
17306 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17307 PyObject *resultobj = 0;
17308 wxICOHandler *result = 0 ;
17309
17310 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17311 {
17312 PyThreadState* __tstate = wxPyBeginAllowThreads();
17313 result = (wxICOHandler *)new wxICOHandler();
17314 wxPyEndAllowThreads(__tstate);
17315 if (PyErr_Occurred()) SWIG_fail;
17316 }
17317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17318 return resultobj;
17319 fail:
17320 return NULL;
17321 }
17322
17323
17324 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17325 PyObject *obj;
17326 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17327 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17328 return SWIG_Py_Void();
17329 }
17330
17331 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17332 return SWIG_Python_InitShadowInstance(args);
17333 }
17334
17335 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17336 PyObject *resultobj = 0;
17337 wxCURHandler *result = 0 ;
17338
17339 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17340 {
17341 PyThreadState* __tstate = wxPyBeginAllowThreads();
17342 result = (wxCURHandler *)new wxCURHandler();
17343 wxPyEndAllowThreads(__tstate);
17344 if (PyErr_Occurred()) SWIG_fail;
17345 }
17346 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17347 return resultobj;
17348 fail:
17349 return NULL;
17350 }
17351
17352
17353 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17354 PyObject *obj;
17355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17356 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17357 return SWIG_Py_Void();
17358 }
17359
17360 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17361 return SWIG_Python_InitShadowInstance(args);
17362 }
17363
17364 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17365 PyObject *resultobj = 0;
17366 wxANIHandler *result = 0 ;
17367
17368 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17369 {
17370 PyThreadState* __tstate = wxPyBeginAllowThreads();
17371 result = (wxANIHandler *)new wxANIHandler();
17372 wxPyEndAllowThreads(__tstate);
17373 if (PyErr_Occurred()) SWIG_fail;
17374 }
17375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17376 return resultobj;
17377 fail:
17378 return NULL;
17379 }
17380
17381
17382 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17383 PyObject *obj;
17384 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17385 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17386 return SWIG_Py_Void();
17387 }
17388
17389 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17390 return SWIG_Python_InitShadowInstance(args);
17391 }
17392
17393 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17394 PyObject *resultobj = 0;
17395 wxPNGHandler *result = 0 ;
17396
17397 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17398 {
17399 PyThreadState* __tstate = wxPyBeginAllowThreads();
17400 result = (wxPNGHandler *)new wxPNGHandler();
17401 wxPyEndAllowThreads(__tstate);
17402 if (PyErr_Occurred()) SWIG_fail;
17403 }
17404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17405 return resultobj;
17406 fail:
17407 return NULL;
17408 }
17409
17410
17411 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17412 PyObject *obj;
17413 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17414 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17415 return SWIG_Py_Void();
17416 }
17417
17418 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17419 return SWIG_Python_InitShadowInstance(args);
17420 }
17421
17422 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17423 PyObject *resultobj = 0;
17424 wxGIFHandler *result = 0 ;
17425
17426 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17427 {
17428 PyThreadState* __tstate = wxPyBeginAllowThreads();
17429 result = (wxGIFHandler *)new wxGIFHandler();
17430 wxPyEndAllowThreads(__tstate);
17431 if (PyErr_Occurred()) SWIG_fail;
17432 }
17433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17434 return resultobj;
17435 fail:
17436 return NULL;
17437 }
17438
17439
17440 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17441 PyObject *obj;
17442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17443 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17444 return SWIG_Py_Void();
17445 }
17446
17447 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17448 return SWIG_Python_InitShadowInstance(args);
17449 }
17450
17451 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17452 PyObject *resultobj = 0;
17453 wxPCXHandler *result = 0 ;
17454
17455 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17456 {
17457 PyThreadState* __tstate = wxPyBeginAllowThreads();
17458 result = (wxPCXHandler *)new wxPCXHandler();
17459 wxPyEndAllowThreads(__tstate);
17460 if (PyErr_Occurred()) SWIG_fail;
17461 }
17462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17463 return resultobj;
17464 fail:
17465 return NULL;
17466 }
17467
17468
17469 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17470 PyObject *obj;
17471 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17472 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17473 return SWIG_Py_Void();
17474 }
17475
17476 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17477 return SWIG_Python_InitShadowInstance(args);
17478 }
17479
17480 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17481 PyObject *resultobj = 0;
17482 wxJPEGHandler *result = 0 ;
17483
17484 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17485 {
17486 PyThreadState* __tstate = wxPyBeginAllowThreads();
17487 result = (wxJPEGHandler *)new wxJPEGHandler();
17488 wxPyEndAllowThreads(__tstate);
17489 if (PyErr_Occurred()) SWIG_fail;
17490 }
17491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17492 return resultobj;
17493 fail:
17494 return NULL;
17495 }
17496
17497
17498 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17499 PyObject *obj;
17500 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17501 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17502 return SWIG_Py_Void();
17503 }
17504
17505 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17506 return SWIG_Python_InitShadowInstance(args);
17507 }
17508
17509 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17510 PyObject *resultobj = 0;
17511 wxPNMHandler *result = 0 ;
17512
17513 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17514 {
17515 PyThreadState* __tstate = wxPyBeginAllowThreads();
17516 result = (wxPNMHandler *)new wxPNMHandler();
17517 wxPyEndAllowThreads(__tstate);
17518 if (PyErr_Occurred()) SWIG_fail;
17519 }
17520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17521 return resultobj;
17522 fail:
17523 return NULL;
17524 }
17525
17526
17527 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17528 PyObject *obj;
17529 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17530 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17531 return SWIG_Py_Void();
17532 }
17533
17534 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17535 return SWIG_Python_InitShadowInstance(args);
17536 }
17537
17538 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17539 PyObject *resultobj = 0;
17540 wxXPMHandler *result = 0 ;
17541
17542 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17543 {
17544 PyThreadState* __tstate = wxPyBeginAllowThreads();
17545 result = (wxXPMHandler *)new wxXPMHandler();
17546 wxPyEndAllowThreads(__tstate);
17547 if (PyErr_Occurred()) SWIG_fail;
17548 }
17549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17550 return resultobj;
17551 fail:
17552 return NULL;
17553 }
17554
17555
17556 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17557 PyObject *obj;
17558 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17559 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17560 return SWIG_Py_Void();
17561 }
17562
17563 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17564 return SWIG_Python_InitShadowInstance(args);
17565 }
17566
17567 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17568 PyObject *resultobj = 0;
17569 wxTIFFHandler *result = 0 ;
17570
17571 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17572 {
17573 PyThreadState* __tstate = wxPyBeginAllowThreads();
17574 result = (wxTIFFHandler *)new wxTIFFHandler();
17575 wxPyEndAllowThreads(__tstate);
17576 if (PyErr_Occurred()) SWIG_fail;
17577 }
17578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17579 return resultobj;
17580 fail:
17581 return NULL;
17582 }
17583
17584
17585 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17586 PyObject *obj;
17587 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17588 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17589 return SWIG_Py_Void();
17590 }
17591
17592 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17593 return SWIG_Python_InitShadowInstance(args);
17594 }
17595
17596 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17597 PyObject *resultobj = 0;
17598 wxImage *arg1 = 0 ;
17599 wxImage *arg2 = 0 ;
17600 int arg3 = (int) 236 ;
17601 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17602 bool result;
17603 void *argp1 = 0 ;
17604 int res1 = 0 ;
17605 void *argp2 = 0 ;
17606 int res2 = 0 ;
17607 int val3 ;
17608 int ecode3 = 0 ;
17609 int val4 ;
17610 int ecode4 = 0 ;
17611 PyObject * obj0 = 0 ;
17612 PyObject * obj1 = 0 ;
17613 PyObject * obj2 = 0 ;
17614 PyObject * obj3 = 0 ;
17615 char * kwnames[] = {
17616 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17617 };
17618
17619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17620 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17621 if (!SWIG_IsOK(res1)) {
17622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17623 }
17624 if (!argp1) {
17625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17626 }
17627 arg1 = reinterpret_cast< wxImage * >(argp1);
17628 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17629 if (!SWIG_IsOK(res2)) {
17630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17631 }
17632 if (!argp2) {
17633 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17634 }
17635 arg2 = reinterpret_cast< wxImage * >(argp2);
17636 if (obj2) {
17637 ecode3 = SWIG_AsVal_int(obj2, &val3);
17638 if (!SWIG_IsOK(ecode3)) {
17639 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17640 }
17641 arg3 = static_cast< int >(val3);
17642 }
17643 if (obj3) {
17644 ecode4 = SWIG_AsVal_int(obj3, &val4);
17645 if (!SWIG_IsOK(ecode4)) {
17646 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17647 }
17648 arg4 = static_cast< int >(val4);
17649 }
17650 {
17651 PyThreadState* __tstate = wxPyBeginAllowThreads();
17652 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17653 wxPyEndAllowThreads(__tstate);
17654 if (PyErr_Occurred()) SWIG_fail;
17655 }
17656 {
17657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17658 }
17659 return resultobj;
17660 fail:
17661 return NULL;
17662 }
17663
17664
17665 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17666 PyObject *obj;
17667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17668 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17669 return SWIG_Py_Void();
17670 }
17671
17672 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17673 PyObject *resultobj = 0;
17674 wxEvtHandler *result = 0 ;
17675
17676 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17677 {
17678 PyThreadState* __tstate = wxPyBeginAllowThreads();
17679 result = (wxEvtHandler *)new wxEvtHandler();
17680 wxPyEndAllowThreads(__tstate);
17681 if (PyErr_Occurred()) SWIG_fail;
17682 }
17683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17684 return resultobj;
17685 fail:
17686 return NULL;
17687 }
17688
17689
17690 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17691 PyObject *resultobj = 0;
17692 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17693 wxEvtHandler *result = 0 ;
17694 void *argp1 = 0 ;
17695 int res1 = 0 ;
17696 PyObject *swig_obj[1] ;
17697
17698 if (!args) SWIG_fail;
17699 swig_obj[0] = args;
17700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17701 if (!SWIG_IsOK(res1)) {
17702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17703 }
17704 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17705 {
17706 PyThreadState* __tstate = wxPyBeginAllowThreads();
17707 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17708 wxPyEndAllowThreads(__tstate);
17709 if (PyErr_Occurred()) SWIG_fail;
17710 }
17711 {
17712 resultobj = wxPyMake_wxObject(result, 0);
17713 }
17714 return resultobj;
17715 fail:
17716 return NULL;
17717 }
17718
17719
17720 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17721 PyObject *resultobj = 0;
17722 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17723 wxEvtHandler *result = 0 ;
17724 void *argp1 = 0 ;
17725 int res1 = 0 ;
17726 PyObject *swig_obj[1] ;
17727
17728 if (!args) SWIG_fail;
17729 swig_obj[0] = args;
17730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17731 if (!SWIG_IsOK(res1)) {
17732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17733 }
17734 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17735 {
17736 PyThreadState* __tstate = wxPyBeginAllowThreads();
17737 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17738 wxPyEndAllowThreads(__tstate);
17739 if (PyErr_Occurred()) SWIG_fail;
17740 }
17741 {
17742 resultobj = wxPyMake_wxObject(result, 0);
17743 }
17744 return resultobj;
17745 fail:
17746 return NULL;
17747 }
17748
17749
17750 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17751 PyObject *resultobj = 0;
17752 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17753 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17754 void *argp1 = 0 ;
17755 int res1 = 0 ;
17756 void *argp2 = 0 ;
17757 int res2 = 0 ;
17758 PyObject * obj0 = 0 ;
17759 PyObject * obj1 = 0 ;
17760 char * kwnames[] = {
17761 (char *) "self",(char *) "handler", NULL
17762 };
17763
17764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17766 if (!SWIG_IsOK(res1)) {
17767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17768 }
17769 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17770 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17771 if (!SWIG_IsOK(res2)) {
17772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17773 }
17774 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17775 {
17776 PyThreadState* __tstate = wxPyBeginAllowThreads();
17777 (arg1)->SetNextHandler(arg2);
17778 wxPyEndAllowThreads(__tstate);
17779 if (PyErr_Occurred()) SWIG_fail;
17780 }
17781 resultobj = SWIG_Py_Void();
17782 return resultobj;
17783 fail:
17784 return NULL;
17785 }
17786
17787
17788 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17789 PyObject *resultobj = 0;
17790 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17791 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17792 void *argp1 = 0 ;
17793 int res1 = 0 ;
17794 void *argp2 = 0 ;
17795 int res2 = 0 ;
17796 PyObject * obj0 = 0 ;
17797 PyObject * obj1 = 0 ;
17798 char * kwnames[] = {
17799 (char *) "self",(char *) "handler", NULL
17800 };
17801
17802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17804 if (!SWIG_IsOK(res1)) {
17805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17806 }
17807 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17808 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17809 if (!SWIG_IsOK(res2)) {
17810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17811 }
17812 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17813 {
17814 PyThreadState* __tstate = wxPyBeginAllowThreads();
17815 (arg1)->SetPreviousHandler(arg2);
17816 wxPyEndAllowThreads(__tstate);
17817 if (PyErr_Occurred()) SWIG_fail;
17818 }
17819 resultobj = SWIG_Py_Void();
17820 return resultobj;
17821 fail:
17822 return NULL;
17823 }
17824
17825
17826 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17827 PyObject *resultobj = 0;
17828 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17829 bool result;
17830 void *argp1 = 0 ;
17831 int res1 = 0 ;
17832 PyObject *swig_obj[1] ;
17833
17834 if (!args) SWIG_fail;
17835 swig_obj[0] = args;
17836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17837 if (!SWIG_IsOK(res1)) {
17838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17839 }
17840 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17841 {
17842 PyThreadState* __tstate = wxPyBeginAllowThreads();
17843 result = (bool)(arg1)->GetEvtHandlerEnabled();
17844 wxPyEndAllowThreads(__tstate);
17845 if (PyErr_Occurred()) SWIG_fail;
17846 }
17847 {
17848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17849 }
17850 return resultobj;
17851 fail:
17852 return NULL;
17853 }
17854
17855
17856 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17857 PyObject *resultobj = 0;
17858 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17859 bool arg2 ;
17860 void *argp1 = 0 ;
17861 int res1 = 0 ;
17862 bool val2 ;
17863 int ecode2 = 0 ;
17864 PyObject * obj0 = 0 ;
17865 PyObject * obj1 = 0 ;
17866 char * kwnames[] = {
17867 (char *) "self",(char *) "enabled", NULL
17868 };
17869
17870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17872 if (!SWIG_IsOK(res1)) {
17873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17874 }
17875 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17876 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17877 if (!SWIG_IsOK(ecode2)) {
17878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17879 }
17880 arg2 = static_cast< bool >(val2);
17881 {
17882 PyThreadState* __tstate = wxPyBeginAllowThreads();
17883 (arg1)->SetEvtHandlerEnabled(arg2);
17884 wxPyEndAllowThreads(__tstate);
17885 if (PyErr_Occurred()) SWIG_fail;
17886 }
17887 resultobj = SWIG_Py_Void();
17888 return resultobj;
17889 fail:
17890 return NULL;
17891 }
17892
17893
17894 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17895 PyObject *resultobj = 0;
17896 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17897 wxEvent *arg2 = 0 ;
17898 bool result;
17899 void *argp1 = 0 ;
17900 int res1 = 0 ;
17901 void *argp2 = 0 ;
17902 int res2 = 0 ;
17903 PyObject * obj0 = 0 ;
17904 PyObject * obj1 = 0 ;
17905 char * kwnames[] = {
17906 (char *) "self",(char *) "event", NULL
17907 };
17908
17909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17911 if (!SWIG_IsOK(res1)) {
17912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17913 }
17914 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17915 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17916 if (!SWIG_IsOK(res2)) {
17917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17918 }
17919 if (!argp2) {
17920 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17921 }
17922 arg2 = reinterpret_cast< wxEvent * >(argp2);
17923 {
17924 PyThreadState* __tstate = wxPyBeginAllowThreads();
17925 result = (bool)(arg1)->ProcessEvent(*arg2);
17926 wxPyEndAllowThreads(__tstate);
17927 if (PyErr_Occurred()) SWIG_fail;
17928 }
17929 {
17930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17931 }
17932 return resultobj;
17933 fail:
17934 return NULL;
17935 }
17936
17937
17938 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17939 PyObject *resultobj = 0;
17940 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17941 wxEvent *arg2 = 0 ;
17942 void *argp1 = 0 ;
17943 int res1 = 0 ;
17944 void *argp2 = 0 ;
17945 int res2 = 0 ;
17946 PyObject * obj0 = 0 ;
17947 PyObject * obj1 = 0 ;
17948 char * kwnames[] = {
17949 (char *) "self",(char *) "event", NULL
17950 };
17951
17952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17954 if (!SWIG_IsOK(res1)) {
17955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17956 }
17957 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17958 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17959 if (!SWIG_IsOK(res2)) {
17960 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17961 }
17962 if (!argp2) {
17963 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17964 }
17965 arg2 = reinterpret_cast< wxEvent * >(argp2);
17966 {
17967 PyThreadState* __tstate = wxPyBeginAllowThreads();
17968 (arg1)->AddPendingEvent(*arg2);
17969 wxPyEndAllowThreads(__tstate);
17970 if (PyErr_Occurred()) SWIG_fail;
17971 }
17972 resultobj = SWIG_Py_Void();
17973 return resultobj;
17974 fail:
17975 return NULL;
17976 }
17977
17978
17979 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17980 PyObject *resultobj = 0;
17981 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17982 void *argp1 = 0 ;
17983 int res1 = 0 ;
17984 PyObject *swig_obj[1] ;
17985
17986 if (!args) SWIG_fail;
17987 swig_obj[0] = args;
17988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17989 if (!SWIG_IsOK(res1)) {
17990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17991 }
17992 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17993 {
17994 PyThreadState* __tstate = wxPyBeginAllowThreads();
17995 (arg1)->ProcessPendingEvents();
17996 wxPyEndAllowThreads(__tstate);
17997 if (PyErr_Occurred()) SWIG_fail;
17998 }
17999 resultobj = SWIG_Py_Void();
18000 return resultobj;
18001 fail:
18002 return NULL;
18003 }
18004
18005
18006 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18007 PyObject *resultobj = 0;
18008 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18009 int arg2 ;
18010 int arg3 ;
18011 int arg4 ;
18012 PyObject *arg5 = (PyObject *) 0 ;
18013 void *argp1 = 0 ;
18014 int res1 = 0 ;
18015 int val2 ;
18016 int ecode2 = 0 ;
18017 int val3 ;
18018 int ecode3 = 0 ;
18019 int val4 ;
18020 int ecode4 = 0 ;
18021 PyObject * obj0 = 0 ;
18022 PyObject * obj1 = 0 ;
18023 PyObject * obj2 = 0 ;
18024 PyObject * obj3 = 0 ;
18025 PyObject * obj4 = 0 ;
18026 char * kwnames[] = {
18027 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18028 };
18029
18030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18032 if (!SWIG_IsOK(res1)) {
18033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18034 }
18035 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18036 ecode2 = SWIG_AsVal_int(obj1, &val2);
18037 if (!SWIG_IsOK(ecode2)) {
18038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18039 }
18040 arg2 = static_cast< int >(val2);
18041 ecode3 = SWIG_AsVal_int(obj2, &val3);
18042 if (!SWIG_IsOK(ecode3)) {
18043 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18044 }
18045 arg3 = static_cast< int >(val3);
18046 ecode4 = SWIG_AsVal_int(obj3, &val4);
18047 if (!SWIG_IsOK(ecode4)) {
18048 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18049 }
18050 arg4 = static_cast< int >(val4);
18051 arg5 = obj4;
18052 {
18053 PyThreadState* __tstate = wxPyBeginAllowThreads();
18054 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18055 wxPyEndAllowThreads(__tstate);
18056 if (PyErr_Occurred()) SWIG_fail;
18057 }
18058 resultobj = SWIG_Py_Void();
18059 return resultobj;
18060 fail:
18061 return NULL;
18062 }
18063
18064
18065 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18066 PyObject *resultobj = 0;
18067 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18068 int arg2 ;
18069 int arg3 = (int) -1 ;
18070 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18071 bool result;
18072 void *argp1 = 0 ;
18073 int res1 = 0 ;
18074 int val2 ;
18075 int ecode2 = 0 ;
18076 int val3 ;
18077 int ecode3 = 0 ;
18078 int val4 ;
18079 int ecode4 = 0 ;
18080 PyObject * obj0 = 0 ;
18081 PyObject * obj1 = 0 ;
18082 PyObject * obj2 = 0 ;
18083 PyObject * obj3 = 0 ;
18084 char * kwnames[] = {
18085 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18086 };
18087
18088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18090 if (!SWIG_IsOK(res1)) {
18091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18092 }
18093 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18094 ecode2 = SWIG_AsVal_int(obj1, &val2);
18095 if (!SWIG_IsOK(ecode2)) {
18096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18097 }
18098 arg2 = static_cast< int >(val2);
18099 if (obj2) {
18100 ecode3 = SWIG_AsVal_int(obj2, &val3);
18101 if (!SWIG_IsOK(ecode3)) {
18102 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18103 }
18104 arg3 = static_cast< int >(val3);
18105 }
18106 if (obj3) {
18107 ecode4 = SWIG_AsVal_int(obj3, &val4);
18108 if (!SWIG_IsOK(ecode4)) {
18109 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18110 }
18111 arg4 = static_cast< wxEventType >(val4);
18112 }
18113 {
18114 PyThreadState* __tstate = wxPyBeginAllowThreads();
18115 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18116 wxPyEndAllowThreads(__tstate);
18117 if (PyErr_Occurred()) SWIG_fail;
18118 }
18119 {
18120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18121 }
18122 return resultobj;
18123 fail:
18124 return NULL;
18125 }
18126
18127
18128 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18129 PyObject *resultobj = 0;
18130 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18131 PyObject *arg2 = (PyObject *) 0 ;
18132 bool arg3 = (bool) true ;
18133 void *argp1 = 0 ;
18134 int res1 = 0 ;
18135 bool val3 ;
18136 int ecode3 = 0 ;
18137 PyObject * obj0 = 0 ;
18138 PyObject * obj1 = 0 ;
18139 PyObject * obj2 = 0 ;
18140 char * kwnames[] = {
18141 (char *) "self",(char *) "_self",(char *) "incref", NULL
18142 };
18143
18144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18146 if (!SWIG_IsOK(res1)) {
18147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18148 }
18149 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18150 arg2 = obj1;
18151 if (obj2) {
18152 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18153 if (!SWIG_IsOK(ecode3)) {
18154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18155 }
18156 arg3 = static_cast< bool >(val3);
18157 }
18158 {
18159 PyThreadState* __tstate = wxPyBeginAllowThreads();
18160 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18161 wxPyEndAllowThreads(__tstate);
18162 if (PyErr_Occurred()) SWIG_fail;
18163 }
18164 resultobj = SWIG_Py_Void();
18165 return resultobj;
18166 fail:
18167 return NULL;
18168 }
18169
18170
18171 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18172 PyObject *obj;
18173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18174 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18175 return SWIG_Py_Void();
18176 }
18177
18178 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18179 return SWIG_Python_InitShadowInstance(args);
18180 }
18181
18182 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18183 PyObject *resultobj = 0;
18184 wxEventType result;
18185
18186 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18187 {
18188 PyThreadState* __tstate = wxPyBeginAllowThreads();
18189 result = (wxEventType)wxNewEventType();
18190 wxPyEndAllowThreads(__tstate);
18191 if (PyErr_Occurred()) SWIG_fail;
18192 }
18193 resultobj = SWIG_From_int(static_cast< int >(result));
18194 return resultobj;
18195 fail:
18196 return NULL;
18197 }
18198
18199
18200 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18201 PyObject *resultobj = 0;
18202 wxEvent *arg1 = (wxEvent *) 0 ;
18203 void *argp1 = 0 ;
18204 int res1 = 0 ;
18205 PyObject *swig_obj[1] ;
18206
18207 if (!args) SWIG_fail;
18208 swig_obj[0] = args;
18209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18210 if (!SWIG_IsOK(res1)) {
18211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18212 }
18213 arg1 = reinterpret_cast< wxEvent * >(argp1);
18214 {
18215 PyThreadState* __tstate = wxPyBeginAllowThreads();
18216 delete arg1;
18217
18218 wxPyEndAllowThreads(__tstate);
18219 if (PyErr_Occurred()) SWIG_fail;
18220 }
18221 resultobj = SWIG_Py_Void();
18222 return resultobj;
18223 fail:
18224 return NULL;
18225 }
18226
18227
18228 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18229 PyObject *resultobj = 0;
18230 wxEvent *arg1 = (wxEvent *) 0 ;
18231 wxEventType arg2 ;
18232 void *argp1 = 0 ;
18233 int res1 = 0 ;
18234 int val2 ;
18235 int ecode2 = 0 ;
18236 PyObject * obj0 = 0 ;
18237 PyObject * obj1 = 0 ;
18238 char * kwnames[] = {
18239 (char *) "self",(char *) "typ", NULL
18240 };
18241
18242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18244 if (!SWIG_IsOK(res1)) {
18245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18246 }
18247 arg1 = reinterpret_cast< wxEvent * >(argp1);
18248 ecode2 = SWIG_AsVal_int(obj1, &val2);
18249 if (!SWIG_IsOK(ecode2)) {
18250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18251 }
18252 arg2 = static_cast< wxEventType >(val2);
18253 {
18254 PyThreadState* __tstate = wxPyBeginAllowThreads();
18255 (arg1)->SetEventType(arg2);
18256 wxPyEndAllowThreads(__tstate);
18257 if (PyErr_Occurred()) SWIG_fail;
18258 }
18259 resultobj = SWIG_Py_Void();
18260 return resultobj;
18261 fail:
18262 return NULL;
18263 }
18264
18265
18266 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18267 PyObject *resultobj = 0;
18268 wxEvent *arg1 = (wxEvent *) 0 ;
18269 wxEventType result;
18270 void *argp1 = 0 ;
18271 int res1 = 0 ;
18272 PyObject *swig_obj[1] ;
18273
18274 if (!args) SWIG_fail;
18275 swig_obj[0] = args;
18276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18277 if (!SWIG_IsOK(res1)) {
18278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18279 }
18280 arg1 = reinterpret_cast< wxEvent * >(argp1);
18281 {
18282 PyThreadState* __tstate = wxPyBeginAllowThreads();
18283 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18284 wxPyEndAllowThreads(__tstate);
18285 if (PyErr_Occurred()) SWIG_fail;
18286 }
18287 resultobj = SWIG_From_int(static_cast< int >(result));
18288 return resultobj;
18289 fail:
18290 return NULL;
18291 }
18292
18293
18294 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18295 PyObject *resultobj = 0;
18296 wxEvent *arg1 = (wxEvent *) 0 ;
18297 wxObject *result = 0 ;
18298 void *argp1 = 0 ;
18299 int res1 = 0 ;
18300 PyObject *swig_obj[1] ;
18301
18302 if (!args) SWIG_fail;
18303 swig_obj[0] = args;
18304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18305 if (!SWIG_IsOK(res1)) {
18306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18307 }
18308 arg1 = reinterpret_cast< wxEvent * >(argp1);
18309 {
18310 PyThreadState* __tstate = wxPyBeginAllowThreads();
18311 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18312 wxPyEndAllowThreads(__tstate);
18313 if (PyErr_Occurred()) SWIG_fail;
18314 }
18315 {
18316 resultobj = wxPyMake_wxObject(result, (bool)0);
18317 }
18318 return resultobj;
18319 fail:
18320 return NULL;
18321 }
18322
18323
18324 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18325 PyObject *resultobj = 0;
18326 wxEvent *arg1 = (wxEvent *) 0 ;
18327 wxObject *arg2 = (wxObject *) 0 ;
18328 void *argp1 = 0 ;
18329 int res1 = 0 ;
18330 void *argp2 = 0 ;
18331 int res2 = 0 ;
18332 PyObject * obj0 = 0 ;
18333 PyObject * obj1 = 0 ;
18334 char * kwnames[] = {
18335 (char *) "self",(char *) "obj", NULL
18336 };
18337
18338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18340 if (!SWIG_IsOK(res1)) {
18341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18342 }
18343 arg1 = reinterpret_cast< wxEvent * >(argp1);
18344 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18345 if (!SWIG_IsOK(res2)) {
18346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18347 }
18348 arg2 = reinterpret_cast< wxObject * >(argp2);
18349 {
18350 PyThreadState* __tstate = wxPyBeginAllowThreads();
18351 (arg1)->SetEventObject(arg2);
18352 wxPyEndAllowThreads(__tstate);
18353 if (PyErr_Occurred()) SWIG_fail;
18354 }
18355 resultobj = SWIG_Py_Void();
18356 return resultobj;
18357 fail:
18358 return NULL;
18359 }
18360
18361
18362 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18363 PyObject *resultobj = 0;
18364 wxEvent *arg1 = (wxEvent *) 0 ;
18365 long result;
18366 void *argp1 = 0 ;
18367 int res1 = 0 ;
18368 PyObject *swig_obj[1] ;
18369
18370 if (!args) SWIG_fail;
18371 swig_obj[0] = args;
18372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18373 if (!SWIG_IsOK(res1)) {
18374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18375 }
18376 arg1 = reinterpret_cast< wxEvent * >(argp1);
18377 {
18378 PyThreadState* __tstate = wxPyBeginAllowThreads();
18379 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18380 wxPyEndAllowThreads(__tstate);
18381 if (PyErr_Occurred()) SWIG_fail;
18382 }
18383 resultobj = SWIG_From_long(static_cast< long >(result));
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18391 PyObject *resultobj = 0;
18392 wxEvent *arg1 = (wxEvent *) 0 ;
18393 long arg2 = (long) 0 ;
18394 void *argp1 = 0 ;
18395 int res1 = 0 ;
18396 long val2 ;
18397 int ecode2 = 0 ;
18398 PyObject * obj0 = 0 ;
18399 PyObject * obj1 = 0 ;
18400 char * kwnames[] = {
18401 (char *) "self",(char *) "ts", NULL
18402 };
18403
18404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18406 if (!SWIG_IsOK(res1)) {
18407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18408 }
18409 arg1 = reinterpret_cast< wxEvent * >(argp1);
18410 if (obj1) {
18411 ecode2 = SWIG_AsVal_long(obj1, &val2);
18412 if (!SWIG_IsOK(ecode2)) {
18413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18414 }
18415 arg2 = static_cast< long >(val2);
18416 }
18417 {
18418 PyThreadState* __tstate = wxPyBeginAllowThreads();
18419 (arg1)->SetTimestamp(arg2);
18420 wxPyEndAllowThreads(__tstate);
18421 if (PyErr_Occurred()) SWIG_fail;
18422 }
18423 resultobj = SWIG_Py_Void();
18424 return resultobj;
18425 fail:
18426 return NULL;
18427 }
18428
18429
18430 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18431 PyObject *resultobj = 0;
18432 wxEvent *arg1 = (wxEvent *) 0 ;
18433 int result;
18434 void *argp1 = 0 ;
18435 int res1 = 0 ;
18436 PyObject *swig_obj[1] ;
18437
18438 if (!args) SWIG_fail;
18439 swig_obj[0] = args;
18440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18441 if (!SWIG_IsOK(res1)) {
18442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18443 }
18444 arg1 = reinterpret_cast< wxEvent * >(argp1);
18445 {
18446 PyThreadState* __tstate = wxPyBeginAllowThreads();
18447 result = (int)((wxEvent const *)arg1)->GetId();
18448 wxPyEndAllowThreads(__tstate);
18449 if (PyErr_Occurred()) SWIG_fail;
18450 }
18451 resultobj = SWIG_From_int(static_cast< int >(result));
18452 return resultobj;
18453 fail:
18454 return NULL;
18455 }
18456
18457
18458 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18459 PyObject *resultobj = 0;
18460 wxEvent *arg1 = (wxEvent *) 0 ;
18461 int arg2 ;
18462 void *argp1 = 0 ;
18463 int res1 = 0 ;
18464 int val2 ;
18465 int ecode2 = 0 ;
18466 PyObject * obj0 = 0 ;
18467 PyObject * obj1 = 0 ;
18468 char * kwnames[] = {
18469 (char *) "self",(char *) "Id", NULL
18470 };
18471
18472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18474 if (!SWIG_IsOK(res1)) {
18475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18476 }
18477 arg1 = reinterpret_cast< wxEvent * >(argp1);
18478 ecode2 = SWIG_AsVal_int(obj1, &val2);
18479 if (!SWIG_IsOK(ecode2)) {
18480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18481 }
18482 arg2 = static_cast< int >(val2);
18483 {
18484 PyThreadState* __tstate = wxPyBeginAllowThreads();
18485 (arg1)->SetId(arg2);
18486 wxPyEndAllowThreads(__tstate);
18487 if (PyErr_Occurred()) SWIG_fail;
18488 }
18489 resultobj = SWIG_Py_Void();
18490 return resultobj;
18491 fail:
18492 return NULL;
18493 }
18494
18495
18496 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18497 PyObject *resultobj = 0;
18498 wxEvent *arg1 = (wxEvent *) 0 ;
18499 bool result;
18500 void *argp1 = 0 ;
18501 int res1 = 0 ;
18502 PyObject *swig_obj[1] ;
18503
18504 if (!args) SWIG_fail;
18505 swig_obj[0] = args;
18506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18507 if (!SWIG_IsOK(res1)) {
18508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18509 }
18510 arg1 = reinterpret_cast< wxEvent * >(argp1);
18511 {
18512 PyThreadState* __tstate = wxPyBeginAllowThreads();
18513 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18514 wxPyEndAllowThreads(__tstate);
18515 if (PyErr_Occurred()) SWIG_fail;
18516 }
18517 {
18518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18519 }
18520 return resultobj;
18521 fail:
18522 return NULL;
18523 }
18524
18525
18526 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18527 PyObject *resultobj = 0;
18528 wxEvent *arg1 = (wxEvent *) 0 ;
18529 bool arg2 = (bool) true ;
18530 void *argp1 = 0 ;
18531 int res1 = 0 ;
18532 bool val2 ;
18533 int ecode2 = 0 ;
18534 PyObject * obj0 = 0 ;
18535 PyObject * obj1 = 0 ;
18536 char * kwnames[] = {
18537 (char *) "self",(char *) "skip", NULL
18538 };
18539
18540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18542 if (!SWIG_IsOK(res1)) {
18543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18544 }
18545 arg1 = reinterpret_cast< wxEvent * >(argp1);
18546 if (obj1) {
18547 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18548 if (!SWIG_IsOK(ecode2)) {
18549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18550 }
18551 arg2 = static_cast< bool >(val2);
18552 }
18553 {
18554 PyThreadState* __tstate = wxPyBeginAllowThreads();
18555 (arg1)->Skip(arg2);
18556 wxPyEndAllowThreads(__tstate);
18557 if (PyErr_Occurred()) SWIG_fail;
18558 }
18559 resultobj = SWIG_Py_Void();
18560 return resultobj;
18561 fail:
18562 return NULL;
18563 }
18564
18565
18566 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18567 PyObject *resultobj = 0;
18568 wxEvent *arg1 = (wxEvent *) 0 ;
18569 bool result;
18570 void *argp1 = 0 ;
18571 int res1 = 0 ;
18572 PyObject *swig_obj[1] ;
18573
18574 if (!args) SWIG_fail;
18575 swig_obj[0] = args;
18576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18577 if (!SWIG_IsOK(res1)) {
18578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18579 }
18580 arg1 = reinterpret_cast< wxEvent * >(argp1);
18581 {
18582 PyThreadState* __tstate = wxPyBeginAllowThreads();
18583 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18584 wxPyEndAllowThreads(__tstate);
18585 if (PyErr_Occurred()) SWIG_fail;
18586 }
18587 {
18588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18589 }
18590 return resultobj;
18591 fail:
18592 return NULL;
18593 }
18594
18595
18596 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18597 PyObject *resultobj = 0;
18598 wxEvent *arg1 = (wxEvent *) 0 ;
18599 bool result;
18600 void *argp1 = 0 ;
18601 int res1 = 0 ;
18602 PyObject *swig_obj[1] ;
18603
18604 if (!args) SWIG_fail;
18605 swig_obj[0] = args;
18606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18607 if (!SWIG_IsOK(res1)) {
18608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18609 }
18610 arg1 = reinterpret_cast< wxEvent * >(argp1);
18611 {
18612 PyThreadState* __tstate = wxPyBeginAllowThreads();
18613 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18614 wxPyEndAllowThreads(__tstate);
18615 if (PyErr_Occurred()) SWIG_fail;
18616 }
18617 {
18618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18619 }
18620 return resultobj;
18621 fail:
18622 return NULL;
18623 }
18624
18625
18626 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18627 PyObject *resultobj = 0;
18628 wxEvent *arg1 = (wxEvent *) 0 ;
18629 int result;
18630 void *argp1 = 0 ;
18631 int res1 = 0 ;
18632 PyObject *swig_obj[1] ;
18633
18634 if (!args) SWIG_fail;
18635 swig_obj[0] = args;
18636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18637 if (!SWIG_IsOK(res1)) {
18638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18639 }
18640 arg1 = reinterpret_cast< wxEvent * >(argp1);
18641 {
18642 PyThreadState* __tstate = wxPyBeginAllowThreads();
18643 result = (int)(arg1)->StopPropagation();
18644 wxPyEndAllowThreads(__tstate);
18645 if (PyErr_Occurred()) SWIG_fail;
18646 }
18647 resultobj = SWIG_From_int(static_cast< int >(result));
18648 return resultobj;
18649 fail:
18650 return NULL;
18651 }
18652
18653
18654 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18655 PyObject *resultobj = 0;
18656 wxEvent *arg1 = (wxEvent *) 0 ;
18657 int arg2 ;
18658 void *argp1 = 0 ;
18659 int res1 = 0 ;
18660 int val2 ;
18661 int ecode2 = 0 ;
18662 PyObject * obj0 = 0 ;
18663 PyObject * obj1 = 0 ;
18664 char * kwnames[] = {
18665 (char *) "self",(char *) "propagationLevel", NULL
18666 };
18667
18668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18670 if (!SWIG_IsOK(res1)) {
18671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18672 }
18673 arg1 = reinterpret_cast< wxEvent * >(argp1);
18674 ecode2 = SWIG_AsVal_int(obj1, &val2);
18675 if (!SWIG_IsOK(ecode2)) {
18676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18677 }
18678 arg2 = static_cast< int >(val2);
18679 {
18680 PyThreadState* __tstate = wxPyBeginAllowThreads();
18681 (arg1)->ResumePropagation(arg2);
18682 wxPyEndAllowThreads(__tstate);
18683 if (PyErr_Occurred()) SWIG_fail;
18684 }
18685 resultobj = SWIG_Py_Void();
18686 return resultobj;
18687 fail:
18688 return NULL;
18689 }
18690
18691
18692 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18693 PyObject *resultobj = 0;
18694 wxEvent *arg1 = (wxEvent *) 0 ;
18695 wxEvent *result = 0 ;
18696 void *argp1 = 0 ;
18697 int res1 = 0 ;
18698 PyObject *swig_obj[1] ;
18699
18700 if (!args) SWIG_fail;
18701 swig_obj[0] = args;
18702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18703 if (!SWIG_IsOK(res1)) {
18704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18705 }
18706 arg1 = reinterpret_cast< wxEvent * >(argp1);
18707 {
18708 PyThreadState* __tstate = wxPyBeginAllowThreads();
18709 result = (wxEvent *)(arg1)->Clone();
18710 wxPyEndAllowThreads(__tstate);
18711 if (PyErr_Occurred()) SWIG_fail;
18712 }
18713 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18714 return resultobj;
18715 fail:
18716 return NULL;
18717 }
18718
18719
18720 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18721 PyObject *obj;
18722 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18723 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18724 return SWIG_Py_Void();
18725 }
18726
18727 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18728 PyObject *resultobj = 0;
18729 wxEvent *arg1 = 0 ;
18730 wxPropagationDisabler *result = 0 ;
18731 void *argp1 = 0 ;
18732 int res1 = 0 ;
18733 PyObject * obj0 = 0 ;
18734 char * kwnames[] = {
18735 (char *) "event", NULL
18736 };
18737
18738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18739 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18740 if (!SWIG_IsOK(res1)) {
18741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18742 }
18743 if (!argp1) {
18744 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18745 }
18746 arg1 = reinterpret_cast< wxEvent * >(argp1);
18747 {
18748 PyThreadState* __tstate = wxPyBeginAllowThreads();
18749 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18750 wxPyEndAllowThreads(__tstate);
18751 if (PyErr_Occurred()) SWIG_fail;
18752 }
18753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18754 return resultobj;
18755 fail:
18756 return NULL;
18757 }
18758
18759
18760 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18761 PyObject *resultobj = 0;
18762 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18763 void *argp1 = 0 ;
18764 int res1 = 0 ;
18765 PyObject *swig_obj[1] ;
18766
18767 if (!args) SWIG_fail;
18768 swig_obj[0] = args;
18769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18770 if (!SWIG_IsOK(res1)) {
18771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18772 }
18773 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18774 {
18775 PyThreadState* __tstate = wxPyBeginAllowThreads();
18776 delete arg1;
18777
18778 wxPyEndAllowThreads(__tstate);
18779 if (PyErr_Occurred()) SWIG_fail;
18780 }
18781 resultobj = SWIG_Py_Void();
18782 return resultobj;
18783 fail:
18784 return NULL;
18785 }
18786
18787
18788 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18789 PyObject *obj;
18790 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18791 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18792 return SWIG_Py_Void();
18793 }
18794
18795 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18796 return SWIG_Python_InitShadowInstance(args);
18797 }
18798
18799 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18800 PyObject *resultobj = 0;
18801 wxEvent *arg1 = 0 ;
18802 wxPropagateOnce *result = 0 ;
18803 void *argp1 = 0 ;
18804 int res1 = 0 ;
18805 PyObject * obj0 = 0 ;
18806 char * kwnames[] = {
18807 (char *) "event", NULL
18808 };
18809
18810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18811 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18812 if (!SWIG_IsOK(res1)) {
18813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18814 }
18815 if (!argp1) {
18816 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18817 }
18818 arg1 = reinterpret_cast< wxEvent * >(argp1);
18819 {
18820 PyThreadState* __tstate = wxPyBeginAllowThreads();
18821 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18822 wxPyEndAllowThreads(__tstate);
18823 if (PyErr_Occurred()) SWIG_fail;
18824 }
18825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18826 return resultobj;
18827 fail:
18828 return NULL;
18829 }
18830
18831
18832 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18833 PyObject *resultobj = 0;
18834 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18835 void *argp1 = 0 ;
18836 int res1 = 0 ;
18837 PyObject *swig_obj[1] ;
18838
18839 if (!args) SWIG_fail;
18840 swig_obj[0] = args;
18841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18842 if (!SWIG_IsOK(res1)) {
18843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18844 }
18845 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18846 {
18847 PyThreadState* __tstate = wxPyBeginAllowThreads();
18848 delete arg1;
18849
18850 wxPyEndAllowThreads(__tstate);
18851 if (PyErr_Occurred()) SWIG_fail;
18852 }
18853 resultobj = SWIG_Py_Void();
18854 return resultobj;
18855 fail:
18856 return NULL;
18857 }
18858
18859
18860 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18861 PyObject *obj;
18862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18863 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18864 return SWIG_Py_Void();
18865 }
18866
18867 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18868 return SWIG_Python_InitShadowInstance(args);
18869 }
18870
18871 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18872 PyObject *resultobj = 0;
18873 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18874 int arg2 = (int) 0 ;
18875 wxCommandEvent *result = 0 ;
18876 int val1 ;
18877 int ecode1 = 0 ;
18878 int val2 ;
18879 int ecode2 = 0 ;
18880 PyObject * obj0 = 0 ;
18881 PyObject * obj1 = 0 ;
18882 char * kwnames[] = {
18883 (char *) "commandType",(char *) "winid", NULL
18884 };
18885
18886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18887 if (obj0) {
18888 ecode1 = SWIG_AsVal_int(obj0, &val1);
18889 if (!SWIG_IsOK(ecode1)) {
18890 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18891 }
18892 arg1 = static_cast< wxEventType >(val1);
18893 }
18894 if (obj1) {
18895 ecode2 = SWIG_AsVal_int(obj1, &val2);
18896 if (!SWIG_IsOK(ecode2)) {
18897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18898 }
18899 arg2 = static_cast< int >(val2);
18900 }
18901 {
18902 PyThreadState* __tstate = wxPyBeginAllowThreads();
18903 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18904 wxPyEndAllowThreads(__tstate);
18905 if (PyErr_Occurred()) SWIG_fail;
18906 }
18907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18908 return resultobj;
18909 fail:
18910 return NULL;
18911 }
18912
18913
18914 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18915 PyObject *resultobj = 0;
18916 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18917 int result;
18918 void *argp1 = 0 ;
18919 int res1 = 0 ;
18920 PyObject *swig_obj[1] ;
18921
18922 if (!args) SWIG_fail;
18923 swig_obj[0] = args;
18924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18925 if (!SWIG_IsOK(res1)) {
18926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18927 }
18928 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18929 {
18930 PyThreadState* __tstate = wxPyBeginAllowThreads();
18931 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18932 wxPyEndAllowThreads(__tstate);
18933 if (PyErr_Occurred()) SWIG_fail;
18934 }
18935 resultobj = SWIG_From_int(static_cast< int >(result));
18936 return resultobj;
18937 fail:
18938 return NULL;
18939 }
18940
18941
18942 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18943 PyObject *resultobj = 0;
18944 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18945 wxString *arg2 = 0 ;
18946 void *argp1 = 0 ;
18947 int res1 = 0 ;
18948 bool temp2 = false ;
18949 PyObject * obj0 = 0 ;
18950 PyObject * obj1 = 0 ;
18951 char * kwnames[] = {
18952 (char *) "self",(char *) "s", NULL
18953 };
18954
18955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18957 if (!SWIG_IsOK(res1)) {
18958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18959 }
18960 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18961 {
18962 arg2 = wxString_in_helper(obj1);
18963 if (arg2 == NULL) SWIG_fail;
18964 temp2 = true;
18965 }
18966 {
18967 PyThreadState* __tstate = wxPyBeginAllowThreads();
18968 (arg1)->SetString((wxString const &)*arg2);
18969 wxPyEndAllowThreads(__tstate);
18970 if (PyErr_Occurred()) SWIG_fail;
18971 }
18972 resultobj = SWIG_Py_Void();
18973 {
18974 if (temp2)
18975 delete arg2;
18976 }
18977 return resultobj;
18978 fail:
18979 {
18980 if (temp2)
18981 delete arg2;
18982 }
18983 return NULL;
18984 }
18985
18986
18987 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18988 PyObject *resultobj = 0;
18989 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18990 wxString result;
18991 void *argp1 = 0 ;
18992 int res1 = 0 ;
18993 PyObject *swig_obj[1] ;
18994
18995 if (!args) SWIG_fail;
18996 swig_obj[0] = args;
18997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18998 if (!SWIG_IsOK(res1)) {
18999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19000 }
19001 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19002 {
19003 PyThreadState* __tstate = wxPyBeginAllowThreads();
19004 result = ((wxCommandEvent const *)arg1)->GetString();
19005 wxPyEndAllowThreads(__tstate);
19006 if (PyErr_Occurred()) SWIG_fail;
19007 }
19008 {
19009 #if wxUSE_UNICODE
19010 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19011 #else
19012 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19013 #endif
19014 }
19015 return resultobj;
19016 fail:
19017 return NULL;
19018 }
19019
19020
19021 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19022 PyObject *resultobj = 0;
19023 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19024 bool result;
19025 void *argp1 = 0 ;
19026 int res1 = 0 ;
19027 PyObject *swig_obj[1] ;
19028
19029 if (!args) SWIG_fail;
19030 swig_obj[0] = args;
19031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19032 if (!SWIG_IsOK(res1)) {
19033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19034 }
19035 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19036 {
19037 PyThreadState* __tstate = wxPyBeginAllowThreads();
19038 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19039 wxPyEndAllowThreads(__tstate);
19040 if (PyErr_Occurred()) SWIG_fail;
19041 }
19042 {
19043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19044 }
19045 return resultobj;
19046 fail:
19047 return NULL;
19048 }
19049
19050
19051 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19052 PyObject *resultobj = 0;
19053 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19054 bool result;
19055 void *argp1 = 0 ;
19056 int res1 = 0 ;
19057 PyObject *swig_obj[1] ;
19058
19059 if (!args) SWIG_fail;
19060 swig_obj[0] = args;
19061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19062 if (!SWIG_IsOK(res1)) {
19063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19064 }
19065 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19066 {
19067 PyThreadState* __tstate = wxPyBeginAllowThreads();
19068 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19069 wxPyEndAllowThreads(__tstate);
19070 if (PyErr_Occurred()) SWIG_fail;
19071 }
19072 {
19073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19074 }
19075 return resultobj;
19076 fail:
19077 return NULL;
19078 }
19079
19080
19081 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19082 PyObject *resultobj = 0;
19083 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19084 long arg2 ;
19085 void *argp1 = 0 ;
19086 int res1 = 0 ;
19087 long val2 ;
19088 int ecode2 = 0 ;
19089 PyObject * obj0 = 0 ;
19090 PyObject * obj1 = 0 ;
19091 char * kwnames[] = {
19092 (char *) "self",(char *) "extraLong", NULL
19093 };
19094
19095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19097 if (!SWIG_IsOK(res1)) {
19098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19099 }
19100 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19101 ecode2 = SWIG_AsVal_long(obj1, &val2);
19102 if (!SWIG_IsOK(ecode2)) {
19103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19104 }
19105 arg2 = static_cast< long >(val2);
19106 {
19107 PyThreadState* __tstate = wxPyBeginAllowThreads();
19108 (arg1)->SetExtraLong(arg2);
19109 wxPyEndAllowThreads(__tstate);
19110 if (PyErr_Occurred()) SWIG_fail;
19111 }
19112 resultobj = SWIG_Py_Void();
19113 return resultobj;
19114 fail:
19115 return NULL;
19116 }
19117
19118
19119 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19120 PyObject *resultobj = 0;
19121 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19122 long result;
19123 void *argp1 = 0 ;
19124 int res1 = 0 ;
19125 PyObject *swig_obj[1] ;
19126
19127 if (!args) SWIG_fail;
19128 swig_obj[0] = args;
19129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19130 if (!SWIG_IsOK(res1)) {
19131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19132 }
19133 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19134 {
19135 PyThreadState* __tstate = wxPyBeginAllowThreads();
19136 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19137 wxPyEndAllowThreads(__tstate);
19138 if (PyErr_Occurred()) SWIG_fail;
19139 }
19140 resultobj = SWIG_From_long(static_cast< long >(result));
19141 return resultobj;
19142 fail:
19143 return NULL;
19144 }
19145
19146
19147 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19148 PyObject *resultobj = 0;
19149 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19150 int arg2 ;
19151 void *argp1 = 0 ;
19152 int res1 = 0 ;
19153 int val2 ;
19154 int ecode2 = 0 ;
19155 PyObject * obj0 = 0 ;
19156 PyObject * obj1 = 0 ;
19157 char * kwnames[] = {
19158 (char *) "self",(char *) "i", NULL
19159 };
19160
19161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19163 if (!SWIG_IsOK(res1)) {
19164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19165 }
19166 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19167 ecode2 = SWIG_AsVal_int(obj1, &val2);
19168 if (!SWIG_IsOK(ecode2)) {
19169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19170 }
19171 arg2 = static_cast< int >(val2);
19172 {
19173 PyThreadState* __tstate = wxPyBeginAllowThreads();
19174 (arg1)->SetInt(arg2);
19175 wxPyEndAllowThreads(__tstate);
19176 if (PyErr_Occurred()) SWIG_fail;
19177 }
19178 resultobj = SWIG_Py_Void();
19179 return resultobj;
19180 fail:
19181 return NULL;
19182 }
19183
19184
19185 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19186 PyObject *resultobj = 0;
19187 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19188 int result;
19189 void *argp1 = 0 ;
19190 int res1 = 0 ;
19191 PyObject *swig_obj[1] ;
19192
19193 if (!args) SWIG_fail;
19194 swig_obj[0] = args;
19195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19196 if (!SWIG_IsOK(res1)) {
19197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19198 }
19199 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19200 {
19201 PyThreadState* __tstate = wxPyBeginAllowThreads();
19202 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19203 wxPyEndAllowThreads(__tstate);
19204 if (PyErr_Occurred()) SWIG_fail;
19205 }
19206 resultobj = SWIG_From_int(static_cast< int >(result));
19207 return resultobj;
19208 fail:
19209 return NULL;
19210 }
19211
19212
19213 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19214 PyObject *resultobj = 0;
19215 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19216 PyObject *result = 0 ;
19217 void *argp1 = 0 ;
19218 int res1 = 0 ;
19219 PyObject *swig_obj[1] ;
19220
19221 if (!args) SWIG_fail;
19222 swig_obj[0] = args;
19223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19224 if (!SWIG_IsOK(res1)) {
19225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19226 }
19227 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19228 {
19229 PyThreadState* __tstate = wxPyBeginAllowThreads();
19230 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19231 wxPyEndAllowThreads(__tstate);
19232 if (PyErr_Occurred()) SWIG_fail;
19233 }
19234 resultobj = result;
19235 return resultobj;
19236 fail:
19237 return NULL;
19238 }
19239
19240
19241 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19242 PyObject *resultobj = 0;
19243 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19244 PyObject *arg2 = (PyObject *) 0 ;
19245 void *argp1 = 0 ;
19246 int res1 = 0 ;
19247 PyObject * obj0 = 0 ;
19248 PyObject * obj1 = 0 ;
19249 char * kwnames[] = {
19250 (char *) "self",(char *) "clientData", NULL
19251 };
19252
19253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19255 if (!SWIG_IsOK(res1)) {
19256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19257 }
19258 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19259 arg2 = obj1;
19260 {
19261 PyThreadState* __tstate = wxPyBeginAllowThreads();
19262 wxCommandEvent_SetClientData(arg1,arg2);
19263 wxPyEndAllowThreads(__tstate);
19264 if (PyErr_Occurred()) SWIG_fail;
19265 }
19266 resultobj = SWIG_Py_Void();
19267 return resultobj;
19268 fail:
19269 return NULL;
19270 }
19271
19272
19273 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19274 PyObject *resultobj = 0;
19275 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19276 wxEvent *result = 0 ;
19277 void *argp1 = 0 ;
19278 int res1 = 0 ;
19279 PyObject *swig_obj[1] ;
19280
19281 if (!args) SWIG_fail;
19282 swig_obj[0] = args;
19283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19284 if (!SWIG_IsOK(res1)) {
19285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19286 }
19287 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19288 {
19289 PyThreadState* __tstate = wxPyBeginAllowThreads();
19290 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19291 wxPyEndAllowThreads(__tstate);
19292 if (PyErr_Occurred()) SWIG_fail;
19293 }
19294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19295 return resultobj;
19296 fail:
19297 return NULL;
19298 }
19299
19300
19301 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19302 PyObject *obj;
19303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19304 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19305 return SWIG_Py_Void();
19306 }
19307
19308 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19309 return SWIG_Python_InitShadowInstance(args);
19310 }
19311
19312 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19313 PyObject *resultobj = 0;
19314 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19315 int arg2 = (int) 0 ;
19316 wxNotifyEvent *result = 0 ;
19317 int val1 ;
19318 int ecode1 = 0 ;
19319 int val2 ;
19320 int ecode2 = 0 ;
19321 PyObject * obj0 = 0 ;
19322 PyObject * obj1 = 0 ;
19323 char * kwnames[] = {
19324 (char *) "commandType",(char *) "winid", NULL
19325 };
19326
19327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19328 if (obj0) {
19329 ecode1 = SWIG_AsVal_int(obj0, &val1);
19330 if (!SWIG_IsOK(ecode1)) {
19331 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19332 }
19333 arg1 = static_cast< wxEventType >(val1);
19334 }
19335 if (obj1) {
19336 ecode2 = SWIG_AsVal_int(obj1, &val2);
19337 if (!SWIG_IsOK(ecode2)) {
19338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19339 }
19340 arg2 = static_cast< int >(val2);
19341 }
19342 {
19343 PyThreadState* __tstate = wxPyBeginAllowThreads();
19344 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19345 wxPyEndAllowThreads(__tstate);
19346 if (PyErr_Occurred()) SWIG_fail;
19347 }
19348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19349 return resultobj;
19350 fail:
19351 return NULL;
19352 }
19353
19354
19355 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19356 PyObject *resultobj = 0;
19357 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19358 void *argp1 = 0 ;
19359 int res1 = 0 ;
19360 PyObject *swig_obj[1] ;
19361
19362 if (!args) SWIG_fail;
19363 swig_obj[0] = args;
19364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19365 if (!SWIG_IsOK(res1)) {
19366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19367 }
19368 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19369 {
19370 PyThreadState* __tstate = wxPyBeginAllowThreads();
19371 (arg1)->Veto();
19372 wxPyEndAllowThreads(__tstate);
19373 if (PyErr_Occurred()) SWIG_fail;
19374 }
19375 resultobj = SWIG_Py_Void();
19376 return resultobj;
19377 fail:
19378 return NULL;
19379 }
19380
19381
19382 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19383 PyObject *resultobj = 0;
19384 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19385 void *argp1 = 0 ;
19386 int res1 = 0 ;
19387 PyObject *swig_obj[1] ;
19388
19389 if (!args) SWIG_fail;
19390 swig_obj[0] = args;
19391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19392 if (!SWIG_IsOK(res1)) {
19393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19394 }
19395 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19396 {
19397 PyThreadState* __tstate = wxPyBeginAllowThreads();
19398 (arg1)->Allow();
19399 wxPyEndAllowThreads(__tstate);
19400 if (PyErr_Occurred()) SWIG_fail;
19401 }
19402 resultobj = SWIG_Py_Void();
19403 return resultobj;
19404 fail:
19405 return NULL;
19406 }
19407
19408
19409 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19410 PyObject *resultobj = 0;
19411 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19412 bool result;
19413 void *argp1 = 0 ;
19414 int res1 = 0 ;
19415 PyObject *swig_obj[1] ;
19416
19417 if (!args) SWIG_fail;
19418 swig_obj[0] = args;
19419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19420 if (!SWIG_IsOK(res1)) {
19421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19422 }
19423 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19424 {
19425 PyThreadState* __tstate = wxPyBeginAllowThreads();
19426 result = (bool)(arg1)->IsAllowed();
19427 wxPyEndAllowThreads(__tstate);
19428 if (PyErr_Occurred()) SWIG_fail;
19429 }
19430 {
19431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19432 }
19433 return resultobj;
19434 fail:
19435 return NULL;
19436 }
19437
19438
19439 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19440 PyObject *obj;
19441 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19442 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19443 return SWIG_Py_Void();
19444 }
19445
19446 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19447 return SWIG_Python_InitShadowInstance(args);
19448 }
19449
19450 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19451 PyObject *resultobj = 0;
19452 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19453 int arg2 = (int) 0 ;
19454 int arg3 = (int) 0 ;
19455 int arg4 = (int) 0 ;
19456 wxScrollEvent *result = 0 ;
19457 int val1 ;
19458 int ecode1 = 0 ;
19459 int val2 ;
19460 int ecode2 = 0 ;
19461 int val3 ;
19462 int ecode3 = 0 ;
19463 int val4 ;
19464 int ecode4 = 0 ;
19465 PyObject * obj0 = 0 ;
19466 PyObject * obj1 = 0 ;
19467 PyObject * obj2 = 0 ;
19468 PyObject * obj3 = 0 ;
19469 char * kwnames[] = {
19470 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19471 };
19472
19473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19474 if (obj0) {
19475 ecode1 = SWIG_AsVal_int(obj0, &val1);
19476 if (!SWIG_IsOK(ecode1)) {
19477 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19478 }
19479 arg1 = static_cast< wxEventType >(val1);
19480 }
19481 if (obj1) {
19482 ecode2 = SWIG_AsVal_int(obj1, &val2);
19483 if (!SWIG_IsOK(ecode2)) {
19484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19485 }
19486 arg2 = static_cast< int >(val2);
19487 }
19488 if (obj2) {
19489 ecode3 = SWIG_AsVal_int(obj2, &val3);
19490 if (!SWIG_IsOK(ecode3)) {
19491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19492 }
19493 arg3 = static_cast< int >(val3);
19494 }
19495 if (obj3) {
19496 ecode4 = SWIG_AsVal_int(obj3, &val4);
19497 if (!SWIG_IsOK(ecode4)) {
19498 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19499 }
19500 arg4 = static_cast< int >(val4);
19501 }
19502 {
19503 PyThreadState* __tstate = wxPyBeginAllowThreads();
19504 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19505 wxPyEndAllowThreads(__tstate);
19506 if (PyErr_Occurred()) SWIG_fail;
19507 }
19508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19509 return resultobj;
19510 fail:
19511 return NULL;
19512 }
19513
19514
19515 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19516 PyObject *resultobj = 0;
19517 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19518 int result;
19519 void *argp1 = 0 ;
19520 int res1 = 0 ;
19521 PyObject *swig_obj[1] ;
19522
19523 if (!args) SWIG_fail;
19524 swig_obj[0] = args;
19525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19526 if (!SWIG_IsOK(res1)) {
19527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19528 }
19529 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19530 {
19531 PyThreadState* __tstate = wxPyBeginAllowThreads();
19532 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19533 wxPyEndAllowThreads(__tstate);
19534 if (PyErr_Occurred()) SWIG_fail;
19535 }
19536 resultobj = SWIG_From_int(static_cast< int >(result));
19537 return resultobj;
19538 fail:
19539 return NULL;
19540 }
19541
19542
19543 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19544 PyObject *resultobj = 0;
19545 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19546 int result;
19547 void *argp1 = 0 ;
19548 int res1 = 0 ;
19549 PyObject *swig_obj[1] ;
19550
19551 if (!args) SWIG_fail;
19552 swig_obj[0] = args;
19553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19554 if (!SWIG_IsOK(res1)) {
19555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19556 }
19557 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19558 {
19559 PyThreadState* __tstate = wxPyBeginAllowThreads();
19560 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19561 wxPyEndAllowThreads(__tstate);
19562 if (PyErr_Occurred()) SWIG_fail;
19563 }
19564 resultobj = SWIG_From_int(static_cast< int >(result));
19565 return resultobj;
19566 fail:
19567 return NULL;
19568 }
19569
19570
19571 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19572 PyObject *resultobj = 0;
19573 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19574 int arg2 ;
19575 void *argp1 = 0 ;
19576 int res1 = 0 ;
19577 int val2 ;
19578 int ecode2 = 0 ;
19579 PyObject * obj0 = 0 ;
19580 PyObject * obj1 = 0 ;
19581 char * kwnames[] = {
19582 (char *) "self",(char *) "orient", NULL
19583 };
19584
19585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19587 if (!SWIG_IsOK(res1)) {
19588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19589 }
19590 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19591 ecode2 = SWIG_AsVal_int(obj1, &val2);
19592 if (!SWIG_IsOK(ecode2)) {
19593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19594 }
19595 arg2 = static_cast< int >(val2);
19596 {
19597 PyThreadState* __tstate = wxPyBeginAllowThreads();
19598 (arg1)->SetOrientation(arg2);
19599 wxPyEndAllowThreads(__tstate);
19600 if (PyErr_Occurred()) SWIG_fail;
19601 }
19602 resultobj = SWIG_Py_Void();
19603 return resultobj;
19604 fail:
19605 return NULL;
19606 }
19607
19608
19609 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19610 PyObject *resultobj = 0;
19611 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19612 int arg2 ;
19613 void *argp1 = 0 ;
19614 int res1 = 0 ;
19615 int val2 ;
19616 int ecode2 = 0 ;
19617 PyObject * obj0 = 0 ;
19618 PyObject * obj1 = 0 ;
19619 char * kwnames[] = {
19620 (char *) "self",(char *) "pos", NULL
19621 };
19622
19623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19625 if (!SWIG_IsOK(res1)) {
19626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19627 }
19628 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19629 ecode2 = SWIG_AsVal_int(obj1, &val2);
19630 if (!SWIG_IsOK(ecode2)) {
19631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19632 }
19633 arg2 = static_cast< int >(val2);
19634 {
19635 PyThreadState* __tstate = wxPyBeginAllowThreads();
19636 (arg1)->SetPosition(arg2);
19637 wxPyEndAllowThreads(__tstate);
19638 if (PyErr_Occurred()) SWIG_fail;
19639 }
19640 resultobj = SWIG_Py_Void();
19641 return resultobj;
19642 fail:
19643 return NULL;
19644 }
19645
19646
19647 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19648 PyObject *obj;
19649 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19650 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19651 return SWIG_Py_Void();
19652 }
19653
19654 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19655 return SWIG_Python_InitShadowInstance(args);
19656 }
19657
19658 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19659 PyObject *resultobj = 0;
19660 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19661 int arg2 = (int) 0 ;
19662 int arg3 = (int) 0 ;
19663 wxScrollWinEvent *result = 0 ;
19664 int val1 ;
19665 int ecode1 = 0 ;
19666 int val2 ;
19667 int ecode2 = 0 ;
19668 int val3 ;
19669 int ecode3 = 0 ;
19670 PyObject * obj0 = 0 ;
19671 PyObject * obj1 = 0 ;
19672 PyObject * obj2 = 0 ;
19673 char * kwnames[] = {
19674 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19675 };
19676
19677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19678 if (obj0) {
19679 ecode1 = SWIG_AsVal_int(obj0, &val1);
19680 if (!SWIG_IsOK(ecode1)) {
19681 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19682 }
19683 arg1 = static_cast< wxEventType >(val1);
19684 }
19685 if (obj1) {
19686 ecode2 = SWIG_AsVal_int(obj1, &val2);
19687 if (!SWIG_IsOK(ecode2)) {
19688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19689 }
19690 arg2 = static_cast< int >(val2);
19691 }
19692 if (obj2) {
19693 ecode3 = SWIG_AsVal_int(obj2, &val3);
19694 if (!SWIG_IsOK(ecode3)) {
19695 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19696 }
19697 arg3 = static_cast< int >(val3);
19698 }
19699 {
19700 PyThreadState* __tstate = wxPyBeginAllowThreads();
19701 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19702 wxPyEndAllowThreads(__tstate);
19703 if (PyErr_Occurred()) SWIG_fail;
19704 }
19705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19706 return resultobj;
19707 fail:
19708 return NULL;
19709 }
19710
19711
19712 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19713 PyObject *resultobj = 0;
19714 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19715 int result;
19716 void *argp1 = 0 ;
19717 int res1 = 0 ;
19718 PyObject *swig_obj[1] ;
19719
19720 if (!args) SWIG_fail;
19721 swig_obj[0] = args;
19722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19723 if (!SWIG_IsOK(res1)) {
19724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19725 }
19726 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19727 {
19728 PyThreadState* __tstate = wxPyBeginAllowThreads();
19729 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19730 wxPyEndAllowThreads(__tstate);
19731 if (PyErr_Occurred()) SWIG_fail;
19732 }
19733 resultobj = SWIG_From_int(static_cast< int >(result));
19734 return resultobj;
19735 fail:
19736 return NULL;
19737 }
19738
19739
19740 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19741 PyObject *resultobj = 0;
19742 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19743 int result;
19744 void *argp1 = 0 ;
19745 int res1 = 0 ;
19746 PyObject *swig_obj[1] ;
19747
19748 if (!args) SWIG_fail;
19749 swig_obj[0] = args;
19750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19751 if (!SWIG_IsOK(res1)) {
19752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19753 }
19754 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19755 {
19756 PyThreadState* __tstate = wxPyBeginAllowThreads();
19757 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19758 wxPyEndAllowThreads(__tstate);
19759 if (PyErr_Occurred()) SWIG_fail;
19760 }
19761 resultobj = SWIG_From_int(static_cast< int >(result));
19762 return resultobj;
19763 fail:
19764 return NULL;
19765 }
19766
19767
19768 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19769 PyObject *resultobj = 0;
19770 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19771 int arg2 ;
19772 void *argp1 = 0 ;
19773 int res1 = 0 ;
19774 int val2 ;
19775 int ecode2 = 0 ;
19776 PyObject * obj0 = 0 ;
19777 PyObject * obj1 = 0 ;
19778 char * kwnames[] = {
19779 (char *) "self",(char *) "orient", NULL
19780 };
19781
19782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19784 if (!SWIG_IsOK(res1)) {
19785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19786 }
19787 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19788 ecode2 = SWIG_AsVal_int(obj1, &val2);
19789 if (!SWIG_IsOK(ecode2)) {
19790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19791 }
19792 arg2 = static_cast< int >(val2);
19793 {
19794 PyThreadState* __tstate = wxPyBeginAllowThreads();
19795 (arg1)->SetOrientation(arg2);
19796 wxPyEndAllowThreads(__tstate);
19797 if (PyErr_Occurred()) SWIG_fail;
19798 }
19799 resultobj = SWIG_Py_Void();
19800 return resultobj;
19801 fail:
19802 return NULL;
19803 }
19804
19805
19806 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19807 PyObject *resultobj = 0;
19808 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19809 int arg2 ;
19810 void *argp1 = 0 ;
19811 int res1 = 0 ;
19812 int val2 ;
19813 int ecode2 = 0 ;
19814 PyObject * obj0 = 0 ;
19815 PyObject * obj1 = 0 ;
19816 char * kwnames[] = {
19817 (char *) "self",(char *) "pos", NULL
19818 };
19819
19820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19822 if (!SWIG_IsOK(res1)) {
19823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19824 }
19825 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19826 ecode2 = SWIG_AsVal_int(obj1, &val2);
19827 if (!SWIG_IsOK(ecode2)) {
19828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19829 }
19830 arg2 = static_cast< int >(val2);
19831 {
19832 PyThreadState* __tstate = wxPyBeginAllowThreads();
19833 (arg1)->SetPosition(arg2);
19834 wxPyEndAllowThreads(__tstate);
19835 if (PyErr_Occurred()) SWIG_fail;
19836 }
19837 resultobj = SWIG_Py_Void();
19838 return resultobj;
19839 fail:
19840 return NULL;
19841 }
19842
19843
19844 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19845 PyObject *obj;
19846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19847 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19848 return SWIG_Py_Void();
19849 }
19850
19851 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19852 return SWIG_Python_InitShadowInstance(args);
19853 }
19854
19855 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19856 PyObject *resultobj = 0;
19857 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19858 wxMouseEvent *result = 0 ;
19859 int val1 ;
19860 int ecode1 = 0 ;
19861 PyObject * obj0 = 0 ;
19862 char * kwnames[] = {
19863 (char *) "mouseType", NULL
19864 };
19865
19866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19867 if (obj0) {
19868 ecode1 = SWIG_AsVal_int(obj0, &val1);
19869 if (!SWIG_IsOK(ecode1)) {
19870 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19871 }
19872 arg1 = static_cast< wxEventType >(val1);
19873 }
19874 {
19875 PyThreadState* __tstate = wxPyBeginAllowThreads();
19876 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19877 wxPyEndAllowThreads(__tstate);
19878 if (PyErr_Occurred()) SWIG_fail;
19879 }
19880 {
19881 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19882 }
19883 return resultobj;
19884 fail:
19885 return NULL;
19886 }
19887
19888
19889 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19890 PyObject *resultobj = 0;
19891 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19892 bool result;
19893 void *argp1 = 0 ;
19894 int res1 = 0 ;
19895 PyObject *swig_obj[1] ;
19896
19897 if (!args) SWIG_fail;
19898 swig_obj[0] = args;
19899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19900 if (!SWIG_IsOK(res1)) {
19901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19902 }
19903 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19904 {
19905 PyThreadState* __tstate = wxPyBeginAllowThreads();
19906 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19907 wxPyEndAllowThreads(__tstate);
19908 if (PyErr_Occurred()) SWIG_fail;
19909 }
19910 {
19911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19912 }
19913 return resultobj;
19914 fail:
19915 return NULL;
19916 }
19917
19918
19919 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19920 PyObject *resultobj = 0;
19921 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19922 int arg2 = (int) wxMOUSE_BTN_ANY ;
19923 bool result;
19924 void *argp1 = 0 ;
19925 int res1 = 0 ;
19926 int val2 ;
19927 int ecode2 = 0 ;
19928 PyObject * obj0 = 0 ;
19929 PyObject * obj1 = 0 ;
19930 char * kwnames[] = {
19931 (char *) "self",(char *) "but", NULL
19932 };
19933
19934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19936 if (!SWIG_IsOK(res1)) {
19937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19938 }
19939 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19940 if (obj1) {
19941 ecode2 = SWIG_AsVal_int(obj1, &val2);
19942 if (!SWIG_IsOK(ecode2)) {
19943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19944 }
19945 arg2 = static_cast< int >(val2);
19946 }
19947 {
19948 PyThreadState* __tstate = wxPyBeginAllowThreads();
19949 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19950 wxPyEndAllowThreads(__tstate);
19951 if (PyErr_Occurred()) SWIG_fail;
19952 }
19953 {
19954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19955 }
19956 return resultobj;
19957 fail:
19958 return NULL;
19959 }
19960
19961
19962 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19963 PyObject *resultobj = 0;
19964 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19965 int arg2 = (int) wxMOUSE_BTN_ANY ;
19966 bool result;
19967 void *argp1 = 0 ;
19968 int res1 = 0 ;
19969 int val2 ;
19970 int ecode2 = 0 ;
19971 PyObject * obj0 = 0 ;
19972 PyObject * obj1 = 0 ;
19973 char * kwnames[] = {
19974 (char *) "self",(char *) "but", NULL
19975 };
19976
19977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19979 if (!SWIG_IsOK(res1)) {
19980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19981 }
19982 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19983 if (obj1) {
19984 ecode2 = SWIG_AsVal_int(obj1, &val2);
19985 if (!SWIG_IsOK(ecode2)) {
19986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19987 }
19988 arg2 = static_cast< int >(val2);
19989 }
19990 {
19991 PyThreadState* __tstate = wxPyBeginAllowThreads();
19992 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19993 wxPyEndAllowThreads(__tstate);
19994 if (PyErr_Occurred()) SWIG_fail;
19995 }
19996 {
19997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19998 }
19999 return resultobj;
20000 fail:
20001 return NULL;
20002 }
20003
20004
20005 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20006 PyObject *resultobj = 0;
20007 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20008 int arg2 = (int) wxMOUSE_BTN_ANY ;
20009 bool result;
20010 void *argp1 = 0 ;
20011 int res1 = 0 ;
20012 int val2 ;
20013 int ecode2 = 0 ;
20014 PyObject * obj0 = 0 ;
20015 PyObject * obj1 = 0 ;
20016 char * kwnames[] = {
20017 (char *) "self",(char *) "but", NULL
20018 };
20019
20020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20022 if (!SWIG_IsOK(res1)) {
20023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20024 }
20025 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20026 if (obj1) {
20027 ecode2 = SWIG_AsVal_int(obj1, &val2);
20028 if (!SWIG_IsOK(ecode2)) {
20029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20030 }
20031 arg2 = static_cast< int >(val2);
20032 }
20033 {
20034 PyThreadState* __tstate = wxPyBeginAllowThreads();
20035 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20036 wxPyEndAllowThreads(__tstate);
20037 if (PyErr_Occurred()) SWIG_fail;
20038 }
20039 {
20040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20041 }
20042 return resultobj;
20043 fail:
20044 return NULL;
20045 }
20046
20047
20048 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20049 PyObject *resultobj = 0;
20050 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20051 int arg2 ;
20052 bool result;
20053 void *argp1 = 0 ;
20054 int res1 = 0 ;
20055 int val2 ;
20056 int ecode2 = 0 ;
20057 PyObject * obj0 = 0 ;
20058 PyObject * obj1 = 0 ;
20059 char * kwnames[] = {
20060 (char *) "self",(char *) "button", NULL
20061 };
20062
20063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20065 if (!SWIG_IsOK(res1)) {
20066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20067 }
20068 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20069 ecode2 = SWIG_AsVal_int(obj1, &val2);
20070 if (!SWIG_IsOK(ecode2)) {
20071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20072 }
20073 arg2 = static_cast< int >(val2);
20074 {
20075 PyThreadState* __tstate = wxPyBeginAllowThreads();
20076 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20077 wxPyEndAllowThreads(__tstate);
20078 if (PyErr_Occurred()) SWIG_fail;
20079 }
20080 {
20081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20082 }
20083 return resultobj;
20084 fail:
20085 return NULL;
20086 }
20087
20088
20089 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20090 PyObject *resultobj = 0;
20091 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20092 int arg2 ;
20093 bool result;
20094 void *argp1 = 0 ;
20095 int res1 = 0 ;
20096 int val2 ;
20097 int ecode2 = 0 ;
20098 PyObject * obj0 = 0 ;
20099 PyObject * obj1 = 0 ;
20100 char * kwnames[] = {
20101 (char *) "self",(char *) "but", NULL
20102 };
20103
20104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20106 if (!SWIG_IsOK(res1)) {
20107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20108 }
20109 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20110 ecode2 = SWIG_AsVal_int(obj1, &val2);
20111 if (!SWIG_IsOK(ecode2)) {
20112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20113 }
20114 arg2 = static_cast< int >(val2);
20115 {
20116 PyThreadState* __tstate = wxPyBeginAllowThreads();
20117 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20118 wxPyEndAllowThreads(__tstate);
20119 if (PyErr_Occurred()) SWIG_fail;
20120 }
20121 {
20122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20123 }
20124 return resultobj;
20125 fail:
20126 return NULL;
20127 }
20128
20129
20130 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20131 PyObject *resultobj = 0;
20132 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20133 int result;
20134 void *argp1 = 0 ;
20135 int res1 = 0 ;
20136 PyObject *swig_obj[1] ;
20137
20138 if (!args) SWIG_fail;
20139 swig_obj[0] = args;
20140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20141 if (!SWIG_IsOK(res1)) {
20142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20143 }
20144 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20145 {
20146 PyThreadState* __tstate = wxPyBeginAllowThreads();
20147 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20148 wxPyEndAllowThreads(__tstate);
20149 if (PyErr_Occurred()) SWIG_fail;
20150 }
20151 resultobj = SWIG_From_int(static_cast< int >(result));
20152 return resultobj;
20153 fail:
20154 return NULL;
20155 }
20156
20157
20158 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20159 PyObject *resultobj = 0;
20160 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20161 bool result;
20162 void *argp1 = 0 ;
20163 int res1 = 0 ;
20164 PyObject *swig_obj[1] ;
20165
20166 if (!args) SWIG_fail;
20167 swig_obj[0] = args;
20168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20169 if (!SWIG_IsOK(res1)) {
20170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20171 }
20172 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20173 {
20174 PyThreadState* __tstate = wxPyBeginAllowThreads();
20175 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20176 wxPyEndAllowThreads(__tstate);
20177 if (PyErr_Occurred()) SWIG_fail;
20178 }
20179 {
20180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20181 }
20182 return resultobj;
20183 fail:
20184 return NULL;
20185 }
20186
20187
20188 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20189 PyObject *resultobj = 0;
20190 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20191 bool result;
20192 void *argp1 = 0 ;
20193 int res1 = 0 ;
20194 PyObject *swig_obj[1] ;
20195
20196 if (!args) SWIG_fail;
20197 swig_obj[0] = args;
20198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20199 if (!SWIG_IsOK(res1)) {
20200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20201 }
20202 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20203 {
20204 PyThreadState* __tstate = wxPyBeginAllowThreads();
20205 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20206 wxPyEndAllowThreads(__tstate);
20207 if (PyErr_Occurred()) SWIG_fail;
20208 }
20209 {
20210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20211 }
20212 return resultobj;
20213 fail:
20214 return NULL;
20215 }
20216
20217
20218 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20219 PyObject *resultobj = 0;
20220 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20221 bool result;
20222 void *argp1 = 0 ;
20223 int res1 = 0 ;
20224 PyObject *swig_obj[1] ;
20225
20226 if (!args) SWIG_fail;
20227 swig_obj[0] = args;
20228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20229 if (!SWIG_IsOK(res1)) {
20230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20231 }
20232 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20233 {
20234 PyThreadState* __tstate = wxPyBeginAllowThreads();
20235 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20236 wxPyEndAllowThreads(__tstate);
20237 if (PyErr_Occurred()) SWIG_fail;
20238 }
20239 {
20240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20241 }
20242 return resultobj;
20243 fail:
20244 return NULL;
20245 }
20246
20247
20248 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20249 PyObject *resultobj = 0;
20250 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20251 bool result;
20252 void *argp1 = 0 ;
20253 int res1 = 0 ;
20254 PyObject *swig_obj[1] ;
20255
20256 if (!args) SWIG_fail;
20257 swig_obj[0] = args;
20258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20259 if (!SWIG_IsOK(res1)) {
20260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20261 }
20262 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20263 {
20264 PyThreadState* __tstate = wxPyBeginAllowThreads();
20265 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20266 wxPyEndAllowThreads(__tstate);
20267 if (PyErr_Occurred()) SWIG_fail;
20268 }
20269 {
20270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20271 }
20272 return resultobj;
20273 fail:
20274 return NULL;
20275 }
20276
20277
20278 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20279 PyObject *resultobj = 0;
20280 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20281 bool result;
20282 void *argp1 = 0 ;
20283 int res1 = 0 ;
20284 PyObject *swig_obj[1] ;
20285
20286 if (!args) SWIG_fail;
20287 swig_obj[0] = args;
20288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20289 if (!SWIG_IsOK(res1)) {
20290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20291 }
20292 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20293 {
20294 PyThreadState* __tstate = wxPyBeginAllowThreads();
20295 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20296 wxPyEndAllowThreads(__tstate);
20297 if (PyErr_Occurred()) SWIG_fail;
20298 }
20299 {
20300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20301 }
20302 return resultobj;
20303 fail:
20304 return NULL;
20305 }
20306
20307
20308 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20309 PyObject *resultobj = 0;
20310 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20311 bool result;
20312 void *argp1 = 0 ;
20313 int res1 = 0 ;
20314 PyObject *swig_obj[1] ;
20315
20316 if (!args) SWIG_fail;
20317 swig_obj[0] = args;
20318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20319 if (!SWIG_IsOK(res1)) {
20320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20321 }
20322 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20323 {
20324 PyThreadState* __tstate = wxPyBeginAllowThreads();
20325 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20326 wxPyEndAllowThreads(__tstate);
20327 if (PyErr_Occurred()) SWIG_fail;
20328 }
20329 {
20330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20331 }
20332 return resultobj;
20333 fail:
20334 return NULL;
20335 }
20336
20337
20338 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20339 PyObject *resultobj = 0;
20340 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20341 bool result;
20342 void *argp1 = 0 ;
20343 int res1 = 0 ;
20344 PyObject *swig_obj[1] ;
20345
20346 if (!args) SWIG_fail;
20347 swig_obj[0] = args;
20348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20349 if (!SWIG_IsOK(res1)) {
20350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20351 }
20352 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20353 {
20354 PyThreadState* __tstate = wxPyBeginAllowThreads();
20355 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20356 wxPyEndAllowThreads(__tstate);
20357 if (PyErr_Occurred()) SWIG_fail;
20358 }
20359 {
20360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20361 }
20362 return resultobj;
20363 fail:
20364 return NULL;
20365 }
20366
20367
20368 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20369 PyObject *resultobj = 0;
20370 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20371 bool result;
20372 void *argp1 = 0 ;
20373 int res1 = 0 ;
20374 PyObject *swig_obj[1] ;
20375
20376 if (!args) SWIG_fail;
20377 swig_obj[0] = args;
20378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20379 if (!SWIG_IsOK(res1)) {
20380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20381 }
20382 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20383 {
20384 PyThreadState* __tstate = wxPyBeginAllowThreads();
20385 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20386 wxPyEndAllowThreads(__tstate);
20387 if (PyErr_Occurred()) SWIG_fail;
20388 }
20389 {
20390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20391 }
20392 return resultobj;
20393 fail:
20394 return NULL;
20395 }
20396
20397
20398 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20399 PyObject *resultobj = 0;
20400 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20401 bool result;
20402 void *argp1 = 0 ;
20403 int res1 = 0 ;
20404 PyObject *swig_obj[1] ;
20405
20406 if (!args) SWIG_fail;
20407 swig_obj[0] = args;
20408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20409 if (!SWIG_IsOK(res1)) {
20410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20411 }
20412 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20413 {
20414 PyThreadState* __tstate = wxPyBeginAllowThreads();
20415 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20416 wxPyEndAllowThreads(__tstate);
20417 if (PyErr_Occurred()) SWIG_fail;
20418 }
20419 {
20420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20421 }
20422 return resultobj;
20423 fail:
20424 return NULL;
20425 }
20426
20427
20428 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20429 PyObject *resultobj = 0;
20430 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20431 bool result;
20432 void *argp1 = 0 ;
20433 int res1 = 0 ;
20434 PyObject *swig_obj[1] ;
20435
20436 if (!args) SWIG_fail;
20437 swig_obj[0] = args;
20438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20439 if (!SWIG_IsOK(res1)) {
20440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20441 }
20442 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20443 {
20444 PyThreadState* __tstate = wxPyBeginAllowThreads();
20445 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20446 wxPyEndAllowThreads(__tstate);
20447 if (PyErr_Occurred()) SWIG_fail;
20448 }
20449 {
20450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20451 }
20452 return resultobj;
20453 fail:
20454 return NULL;
20455 }
20456
20457
20458 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20459 PyObject *resultobj = 0;
20460 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20461 bool result;
20462 void *argp1 = 0 ;
20463 int res1 = 0 ;
20464 PyObject *swig_obj[1] ;
20465
20466 if (!args) SWIG_fail;
20467 swig_obj[0] = args;
20468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20469 if (!SWIG_IsOK(res1)) {
20470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20471 }
20472 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20473 {
20474 PyThreadState* __tstate = wxPyBeginAllowThreads();
20475 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20476 wxPyEndAllowThreads(__tstate);
20477 if (PyErr_Occurred()) SWIG_fail;
20478 }
20479 {
20480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20481 }
20482 return resultobj;
20483 fail:
20484 return NULL;
20485 }
20486
20487
20488 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20489 PyObject *resultobj = 0;
20490 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20491 bool result;
20492 void *argp1 = 0 ;
20493 int res1 = 0 ;
20494 PyObject *swig_obj[1] ;
20495
20496 if (!args) SWIG_fail;
20497 swig_obj[0] = args;
20498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20499 if (!SWIG_IsOK(res1)) {
20500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20501 }
20502 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20503 {
20504 PyThreadState* __tstate = wxPyBeginAllowThreads();
20505 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20506 wxPyEndAllowThreads(__tstate);
20507 if (PyErr_Occurred()) SWIG_fail;
20508 }
20509 {
20510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20511 }
20512 return resultobj;
20513 fail:
20514 return NULL;
20515 }
20516
20517
20518 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20519 PyObject *resultobj = 0;
20520 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20521 bool result;
20522 void *argp1 = 0 ;
20523 int res1 = 0 ;
20524 PyObject *swig_obj[1] ;
20525
20526 if (!args) SWIG_fail;
20527 swig_obj[0] = args;
20528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20529 if (!SWIG_IsOK(res1)) {
20530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20531 }
20532 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20533 {
20534 PyThreadState* __tstate = wxPyBeginAllowThreads();
20535 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20536 wxPyEndAllowThreads(__tstate);
20537 if (PyErr_Occurred()) SWIG_fail;
20538 }
20539 {
20540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20541 }
20542 return resultobj;
20543 fail:
20544 return NULL;
20545 }
20546
20547
20548 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20549 PyObject *resultobj = 0;
20550 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20551 bool result;
20552 void *argp1 = 0 ;
20553 int res1 = 0 ;
20554 PyObject *swig_obj[1] ;
20555
20556 if (!args) SWIG_fail;
20557 swig_obj[0] = args;
20558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20559 if (!SWIG_IsOK(res1)) {
20560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20561 }
20562 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20563 {
20564 PyThreadState* __tstate = wxPyBeginAllowThreads();
20565 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20566 wxPyEndAllowThreads(__tstate);
20567 if (PyErr_Occurred()) SWIG_fail;
20568 }
20569 {
20570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20571 }
20572 return resultobj;
20573 fail:
20574 return NULL;
20575 }
20576
20577
20578 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20579 PyObject *resultobj = 0;
20580 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20581 bool result;
20582 void *argp1 = 0 ;
20583 int res1 = 0 ;
20584 PyObject *swig_obj[1] ;
20585
20586 if (!args) SWIG_fail;
20587 swig_obj[0] = args;
20588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20589 if (!SWIG_IsOK(res1)) {
20590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20591 }
20592 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20593 {
20594 PyThreadState* __tstate = wxPyBeginAllowThreads();
20595 result = (bool)(arg1)->LeftIsDown();
20596 wxPyEndAllowThreads(__tstate);
20597 if (PyErr_Occurred()) SWIG_fail;
20598 }
20599 {
20600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20601 }
20602 return resultobj;
20603 fail:
20604 return NULL;
20605 }
20606
20607
20608 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20609 PyObject *resultobj = 0;
20610 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20611 bool result;
20612 void *argp1 = 0 ;
20613 int res1 = 0 ;
20614 PyObject *swig_obj[1] ;
20615
20616 if (!args) SWIG_fail;
20617 swig_obj[0] = args;
20618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20619 if (!SWIG_IsOK(res1)) {
20620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20621 }
20622 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20623 {
20624 PyThreadState* __tstate = wxPyBeginAllowThreads();
20625 result = (bool)(arg1)->MiddleIsDown();
20626 wxPyEndAllowThreads(__tstate);
20627 if (PyErr_Occurred()) SWIG_fail;
20628 }
20629 {
20630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20631 }
20632 return resultobj;
20633 fail:
20634 return NULL;
20635 }
20636
20637
20638 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20639 PyObject *resultobj = 0;
20640 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20641 bool result;
20642 void *argp1 = 0 ;
20643 int res1 = 0 ;
20644 PyObject *swig_obj[1] ;
20645
20646 if (!args) SWIG_fail;
20647 swig_obj[0] = args;
20648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20649 if (!SWIG_IsOK(res1)) {
20650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20651 }
20652 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20653 {
20654 PyThreadState* __tstate = wxPyBeginAllowThreads();
20655 result = (bool)(arg1)->RightIsDown();
20656 wxPyEndAllowThreads(__tstate);
20657 if (PyErr_Occurred()) SWIG_fail;
20658 }
20659 {
20660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20661 }
20662 return resultobj;
20663 fail:
20664 return NULL;
20665 }
20666
20667
20668 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20669 PyObject *resultobj = 0;
20670 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20671 bool result;
20672 void *argp1 = 0 ;
20673 int res1 = 0 ;
20674 PyObject *swig_obj[1] ;
20675
20676 if (!args) SWIG_fail;
20677 swig_obj[0] = args;
20678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20679 if (!SWIG_IsOK(res1)) {
20680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20681 }
20682 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20683 {
20684 PyThreadState* __tstate = wxPyBeginAllowThreads();
20685 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20686 wxPyEndAllowThreads(__tstate);
20687 if (PyErr_Occurred()) SWIG_fail;
20688 }
20689 {
20690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20691 }
20692 return resultobj;
20693 fail:
20694 return NULL;
20695 }
20696
20697
20698 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20699 PyObject *resultobj = 0;
20700 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20701 bool result;
20702 void *argp1 = 0 ;
20703 int res1 = 0 ;
20704 PyObject *swig_obj[1] ;
20705
20706 if (!args) SWIG_fail;
20707 swig_obj[0] = args;
20708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20709 if (!SWIG_IsOK(res1)) {
20710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20711 }
20712 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20713 {
20714 PyThreadState* __tstate = wxPyBeginAllowThreads();
20715 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20716 wxPyEndAllowThreads(__tstate);
20717 if (PyErr_Occurred()) SWIG_fail;
20718 }
20719 {
20720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20721 }
20722 return resultobj;
20723 fail:
20724 return NULL;
20725 }
20726
20727
20728 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20729 PyObject *resultobj = 0;
20730 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20731 bool result;
20732 void *argp1 = 0 ;
20733 int res1 = 0 ;
20734 PyObject *swig_obj[1] ;
20735
20736 if (!args) SWIG_fail;
20737 swig_obj[0] = args;
20738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20739 if (!SWIG_IsOK(res1)) {
20740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20741 }
20742 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20743 {
20744 PyThreadState* __tstate = wxPyBeginAllowThreads();
20745 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20746 wxPyEndAllowThreads(__tstate);
20747 if (PyErr_Occurred()) SWIG_fail;
20748 }
20749 {
20750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20751 }
20752 return resultobj;
20753 fail:
20754 return NULL;
20755 }
20756
20757
20758 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20759 PyObject *resultobj = 0;
20760 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20761 bool result;
20762 void *argp1 = 0 ;
20763 int res1 = 0 ;
20764 PyObject *swig_obj[1] ;
20765
20766 if (!args) SWIG_fail;
20767 swig_obj[0] = args;
20768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20769 if (!SWIG_IsOK(res1)) {
20770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20771 }
20772 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20773 {
20774 PyThreadState* __tstate = wxPyBeginAllowThreads();
20775 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20776 wxPyEndAllowThreads(__tstate);
20777 if (PyErr_Occurred()) SWIG_fail;
20778 }
20779 {
20780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20781 }
20782 return resultobj;
20783 fail:
20784 return NULL;
20785 }
20786
20787
20788 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20789 PyObject *resultobj = 0;
20790 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20791 wxPoint result;
20792 void *argp1 = 0 ;
20793 int res1 = 0 ;
20794 PyObject *swig_obj[1] ;
20795
20796 if (!args) SWIG_fail;
20797 swig_obj[0] = args;
20798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20799 if (!SWIG_IsOK(res1)) {
20800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20801 }
20802 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20803 {
20804 PyThreadState* __tstate = wxPyBeginAllowThreads();
20805 result = (arg1)->GetPosition();
20806 wxPyEndAllowThreads(__tstate);
20807 if (PyErr_Occurred()) SWIG_fail;
20808 }
20809 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20810 return resultobj;
20811 fail:
20812 return NULL;
20813 }
20814
20815
20816 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20817 PyObject *resultobj = 0;
20818 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20819 long *arg2 = (long *) 0 ;
20820 long *arg3 = (long *) 0 ;
20821 void *argp1 = 0 ;
20822 int res1 = 0 ;
20823 long temp2 ;
20824 int res2 = SWIG_TMPOBJ ;
20825 long temp3 ;
20826 int res3 = SWIG_TMPOBJ ;
20827 PyObject *swig_obj[1] ;
20828
20829 arg2 = &temp2;
20830 arg3 = &temp3;
20831 if (!args) SWIG_fail;
20832 swig_obj[0] = args;
20833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20834 if (!SWIG_IsOK(res1)) {
20835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20836 }
20837 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20838 {
20839 PyThreadState* __tstate = wxPyBeginAllowThreads();
20840 (arg1)->GetPosition(arg2,arg3);
20841 wxPyEndAllowThreads(__tstate);
20842 if (PyErr_Occurred()) SWIG_fail;
20843 }
20844 resultobj = SWIG_Py_Void();
20845 if (SWIG_IsTmpObj(res2)) {
20846 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20847 } else {
20848 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20849 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20850 }
20851 if (SWIG_IsTmpObj(res3)) {
20852 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20853 } else {
20854 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20856 }
20857 return resultobj;
20858 fail:
20859 return NULL;
20860 }
20861
20862
20863 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20864 PyObject *resultobj = 0;
20865 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20866 wxDC *arg2 = 0 ;
20867 wxPoint result;
20868 void *argp1 = 0 ;
20869 int res1 = 0 ;
20870 void *argp2 = 0 ;
20871 int res2 = 0 ;
20872 PyObject * obj0 = 0 ;
20873 PyObject * obj1 = 0 ;
20874 char * kwnames[] = {
20875 (char *) "self",(char *) "dc", NULL
20876 };
20877
20878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20880 if (!SWIG_IsOK(res1)) {
20881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20882 }
20883 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20884 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20885 if (!SWIG_IsOK(res2)) {
20886 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20887 }
20888 if (!argp2) {
20889 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20890 }
20891 arg2 = reinterpret_cast< wxDC * >(argp2);
20892 {
20893 PyThreadState* __tstate = wxPyBeginAllowThreads();
20894 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20895 wxPyEndAllowThreads(__tstate);
20896 if (PyErr_Occurred()) SWIG_fail;
20897 }
20898 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20899 return resultobj;
20900 fail:
20901 return NULL;
20902 }
20903
20904
20905 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20906 PyObject *resultobj = 0;
20907 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20908 int result;
20909 void *argp1 = 0 ;
20910 int res1 = 0 ;
20911 PyObject *swig_obj[1] ;
20912
20913 if (!args) SWIG_fail;
20914 swig_obj[0] = args;
20915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20916 if (!SWIG_IsOK(res1)) {
20917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20918 }
20919 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20920 {
20921 PyThreadState* __tstate = wxPyBeginAllowThreads();
20922 result = (int)((wxMouseEvent const *)arg1)->GetX();
20923 wxPyEndAllowThreads(__tstate);
20924 if (PyErr_Occurred()) SWIG_fail;
20925 }
20926 resultobj = SWIG_From_int(static_cast< int >(result));
20927 return resultobj;
20928 fail:
20929 return NULL;
20930 }
20931
20932
20933 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20934 PyObject *resultobj = 0;
20935 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20936 int result;
20937 void *argp1 = 0 ;
20938 int res1 = 0 ;
20939 PyObject *swig_obj[1] ;
20940
20941 if (!args) SWIG_fail;
20942 swig_obj[0] = args;
20943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20944 if (!SWIG_IsOK(res1)) {
20945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20946 }
20947 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20948 {
20949 PyThreadState* __tstate = wxPyBeginAllowThreads();
20950 result = (int)((wxMouseEvent const *)arg1)->GetY();
20951 wxPyEndAllowThreads(__tstate);
20952 if (PyErr_Occurred()) SWIG_fail;
20953 }
20954 resultobj = SWIG_From_int(static_cast< int >(result));
20955 return resultobj;
20956 fail:
20957 return NULL;
20958 }
20959
20960
20961 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20962 PyObject *resultobj = 0;
20963 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20964 int result;
20965 void *argp1 = 0 ;
20966 int res1 = 0 ;
20967 PyObject *swig_obj[1] ;
20968
20969 if (!args) SWIG_fail;
20970 swig_obj[0] = args;
20971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20972 if (!SWIG_IsOK(res1)) {
20973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20974 }
20975 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20976 {
20977 PyThreadState* __tstate = wxPyBeginAllowThreads();
20978 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20979 wxPyEndAllowThreads(__tstate);
20980 if (PyErr_Occurred()) SWIG_fail;
20981 }
20982 resultobj = SWIG_From_int(static_cast< int >(result));
20983 return resultobj;
20984 fail:
20985 return NULL;
20986 }
20987
20988
20989 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20990 PyObject *resultobj = 0;
20991 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20992 int result;
20993 void *argp1 = 0 ;
20994 int res1 = 0 ;
20995 PyObject *swig_obj[1] ;
20996
20997 if (!args) SWIG_fail;
20998 swig_obj[0] = args;
20999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21000 if (!SWIG_IsOK(res1)) {
21001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21002 }
21003 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21004 {
21005 PyThreadState* __tstate = wxPyBeginAllowThreads();
21006 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21007 wxPyEndAllowThreads(__tstate);
21008 if (PyErr_Occurred()) SWIG_fail;
21009 }
21010 resultobj = SWIG_From_int(static_cast< int >(result));
21011 return resultobj;
21012 fail:
21013 return NULL;
21014 }
21015
21016
21017 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21018 PyObject *resultobj = 0;
21019 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21020 int result;
21021 void *argp1 = 0 ;
21022 int res1 = 0 ;
21023 PyObject *swig_obj[1] ;
21024
21025 if (!args) SWIG_fail;
21026 swig_obj[0] = args;
21027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21028 if (!SWIG_IsOK(res1)) {
21029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21030 }
21031 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21032 {
21033 PyThreadState* __tstate = wxPyBeginAllowThreads();
21034 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21035 wxPyEndAllowThreads(__tstate);
21036 if (PyErr_Occurred()) SWIG_fail;
21037 }
21038 resultobj = SWIG_From_int(static_cast< int >(result));
21039 return resultobj;
21040 fail:
21041 return NULL;
21042 }
21043
21044
21045 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21046 PyObject *resultobj = 0;
21047 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21048 bool result;
21049 void *argp1 = 0 ;
21050 int res1 = 0 ;
21051 PyObject *swig_obj[1] ;
21052
21053 if (!args) SWIG_fail;
21054 swig_obj[0] = args;
21055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21056 if (!SWIG_IsOK(res1)) {
21057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21058 }
21059 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21060 {
21061 PyThreadState* __tstate = wxPyBeginAllowThreads();
21062 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21063 wxPyEndAllowThreads(__tstate);
21064 if (PyErr_Occurred()) SWIG_fail;
21065 }
21066 {
21067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21068 }
21069 return resultobj;
21070 fail:
21071 return NULL;
21072 }
21073
21074
21075 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21076 PyObject *resultobj = 0;
21077 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21078 int arg2 ;
21079 void *argp1 = 0 ;
21080 int res1 = 0 ;
21081 int val2 ;
21082 int ecode2 = 0 ;
21083 PyObject *swig_obj[2] ;
21084
21085 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21087 if (!SWIG_IsOK(res1)) {
21088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21089 }
21090 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21091 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21092 if (!SWIG_IsOK(ecode2)) {
21093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21094 }
21095 arg2 = static_cast< int >(val2);
21096 if (arg1) (arg1)->m_x = arg2;
21097
21098 resultobj = SWIG_Py_Void();
21099 return resultobj;
21100 fail:
21101 return NULL;
21102 }
21103
21104
21105 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21106 PyObject *resultobj = 0;
21107 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21108 int result;
21109 void *argp1 = 0 ;
21110 int res1 = 0 ;
21111 PyObject *swig_obj[1] ;
21112
21113 if (!args) SWIG_fail;
21114 swig_obj[0] = args;
21115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21116 if (!SWIG_IsOK(res1)) {
21117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21118 }
21119 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21120 result = (int) ((arg1)->m_x);
21121 resultobj = SWIG_From_int(static_cast< int >(result));
21122 return resultobj;
21123 fail:
21124 return NULL;
21125 }
21126
21127
21128 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21129 PyObject *resultobj = 0;
21130 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21131 int arg2 ;
21132 void *argp1 = 0 ;
21133 int res1 = 0 ;
21134 int val2 ;
21135 int ecode2 = 0 ;
21136 PyObject *swig_obj[2] ;
21137
21138 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21140 if (!SWIG_IsOK(res1)) {
21141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21142 }
21143 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21144 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21145 if (!SWIG_IsOK(ecode2)) {
21146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21147 }
21148 arg2 = static_cast< int >(val2);
21149 if (arg1) (arg1)->m_y = arg2;
21150
21151 resultobj = SWIG_Py_Void();
21152 return resultobj;
21153 fail:
21154 return NULL;
21155 }
21156
21157
21158 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21159 PyObject *resultobj = 0;
21160 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21161 int result;
21162 void *argp1 = 0 ;
21163 int res1 = 0 ;
21164 PyObject *swig_obj[1] ;
21165
21166 if (!args) SWIG_fail;
21167 swig_obj[0] = args;
21168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21169 if (!SWIG_IsOK(res1)) {
21170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21171 }
21172 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21173 result = (int) ((arg1)->m_y);
21174 resultobj = SWIG_From_int(static_cast< int >(result));
21175 return resultobj;
21176 fail:
21177 return NULL;
21178 }
21179
21180
21181 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21182 PyObject *resultobj = 0;
21183 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21184 bool arg2 ;
21185 void *argp1 = 0 ;
21186 int res1 = 0 ;
21187 bool val2 ;
21188 int ecode2 = 0 ;
21189 PyObject *swig_obj[2] ;
21190
21191 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21193 if (!SWIG_IsOK(res1)) {
21194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21195 }
21196 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21197 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21198 if (!SWIG_IsOK(ecode2)) {
21199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21200 }
21201 arg2 = static_cast< bool >(val2);
21202 if (arg1) (arg1)->m_leftDown = arg2;
21203
21204 resultobj = SWIG_Py_Void();
21205 return resultobj;
21206 fail:
21207 return NULL;
21208 }
21209
21210
21211 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21212 PyObject *resultobj = 0;
21213 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21214 bool result;
21215 void *argp1 = 0 ;
21216 int res1 = 0 ;
21217 PyObject *swig_obj[1] ;
21218
21219 if (!args) SWIG_fail;
21220 swig_obj[0] = args;
21221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21222 if (!SWIG_IsOK(res1)) {
21223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21224 }
21225 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21226 result = (bool) ((arg1)->m_leftDown);
21227 {
21228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21229 }
21230 return resultobj;
21231 fail:
21232 return NULL;
21233 }
21234
21235
21236 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21237 PyObject *resultobj = 0;
21238 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21239 bool arg2 ;
21240 void *argp1 = 0 ;
21241 int res1 = 0 ;
21242 bool val2 ;
21243 int ecode2 = 0 ;
21244 PyObject *swig_obj[2] ;
21245
21246 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21248 if (!SWIG_IsOK(res1)) {
21249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21250 }
21251 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21252 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21253 if (!SWIG_IsOK(ecode2)) {
21254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21255 }
21256 arg2 = static_cast< bool >(val2);
21257 if (arg1) (arg1)->m_middleDown = arg2;
21258
21259 resultobj = SWIG_Py_Void();
21260 return resultobj;
21261 fail:
21262 return NULL;
21263 }
21264
21265
21266 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21267 PyObject *resultobj = 0;
21268 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21269 bool result;
21270 void *argp1 = 0 ;
21271 int res1 = 0 ;
21272 PyObject *swig_obj[1] ;
21273
21274 if (!args) SWIG_fail;
21275 swig_obj[0] = args;
21276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21277 if (!SWIG_IsOK(res1)) {
21278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21279 }
21280 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21281 result = (bool) ((arg1)->m_middleDown);
21282 {
21283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21284 }
21285 return resultobj;
21286 fail:
21287 return NULL;
21288 }
21289
21290
21291 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21292 PyObject *resultobj = 0;
21293 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21294 bool arg2 ;
21295 void *argp1 = 0 ;
21296 int res1 = 0 ;
21297 bool val2 ;
21298 int ecode2 = 0 ;
21299 PyObject *swig_obj[2] ;
21300
21301 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21303 if (!SWIG_IsOK(res1)) {
21304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21305 }
21306 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21307 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21308 if (!SWIG_IsOK(ecode2)) {
21309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21310 }
21311 arg2 = static_cast< bool >(val2);
21312 if (arg1) (arg1)->m_rightDown = arg2;
21313
21314 resultobj = SWIG_Py_Void();
21315 return resultobj;
21316 fail:
21317 return NULL;
21318 }
21319
21320
21321 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21322 PyObject *resultobj = 0;
21323 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21324 bool result;
21325 void *argp1 = 0 ;
21326 int res1 = 0 ;
21327 PyObject *swig_obj[1] ;
21328
21329 if (!args) SWIG_fail;
21330 swig_obj[0] = args;
21331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21332 if (!SWIG_IsOK(res1)) {
21333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21334 }
21335 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21336 result = (bool) ((arg1)->m_rightDown);
21337 {
21338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21339 }
21340 return resultobj;
21341 fail:
21342 return NULL;
21343 }
21344
21345
21346 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21347 PyObject *resultobj = 0;
21348 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21349 bool arg2 ;
21350 void *argp1 = 0 ;
21351 int res1 = 0 ;
21352 bool val2 ;
21353 int ecode2 = 0 ;
21354 PyObject *swig_obj[2] ;
21355
21356 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21358 if (!SWIG_IsOK(res1)) {
21359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21360 }
21361 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21362 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21363 if (!SWIG_IsOK(ecode2)) {
21364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21365 }
21366 arg2 = static_cast< bool >(val2);
21367 if (arg1) (arg1)->m_controlDown = arg2;
21368
21369 resultobj = SWIG_Py_Void();
21370 return resultobj;
21371 fail:
21372 return NULL;
21373 }
21374
21375
21376 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21377 PyObject *resultobj = 0;
21378 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21379 bool result;
21380 void *argp1 = 0 ;
21381 int res1 = 0 ;
21382 PyObject *swig_obj[1] ;
21383
21384 if (!args) SWIG_fail;
21385 swig_obj[0] = args;
21386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21387 if (!SWIG_IsOK(res1)) {
21388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21389 }
21390 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21391 result = (bool) ((arg1)->m_controlDown);
21392 {
21393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21394 }
21395 return resultobj;
21396 fail:
21397 return NULL;
21398 }
21399
21400
21401 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21402 PyObject *resultobj = 0;
21403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21404 bool arg2 ;
21405 void *argp1 = 0 ;
21406 int res1 = 0 ;
21407 bool val2 ;
21408 int ecode2 = 0 ;
21409 PyObject *swig_obj[2] ;
21410
21411 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21413 if (!SWIG_IsOK(res1)) {
21414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21415 }
21416 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21417 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21418 if (!SWIG_IsOK(ecode2)) {
21419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21420 }
21421 arg2 = static_cast< bool >(val2);
21422 if (arg1) (arg1)->m_shiftDown = arg2;
21423
21424 resultobj = SWIG_Py_Void();
21425 return resultobj;
21426 fail:
21427 return NULL;
21428 }
21429
21430
21431 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21432 PyObject *resultobj = 0;
21433 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21434 bool result;
21435 void *argp1 = 0 ;
21436 int res1 = 0 ;
21437 PyObject *swig_obj[1] ;
21438
21439 if (!args) SWIG_fail;
21440 swig_obj[0] = args;
21441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21442 if (!SWIG_IsOK(res1)) {
21443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21444 }
21445 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21446 result = (bool) ((arg1)->m_shiftDown);
21447 {
21448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21449 }
21450 return resultobj;
21451 fail:
21452 return NULL;
21453 }
21454
21455
21456 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21457 PyObject *resultobj = 0;
21458 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21459 bool arg2 ;
21460 void *argp1 = 0 ;
21461 int res1 = 0 ;
21462 bool val2 ;
21463 int ecode2 = 0 ;
21464 PyObject *swig_obj[2] ;
21465
21466 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21468 if (!SWIG_IsOK(res1)) {
21469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21470 }
21471 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21472 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21473 if (!SWIG_IsOK(ecode2)) {
21474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21475 }
21476 arg2 = static_cast< bool >(val2);
21477 if (arg1) (arg1)->m_altDown = arg2;
21478
21479 resultobj = SWIG_Py_Void();
21480 return resultobj;
21481 fail:
21482 return NULL;
21483 }
21484
21485
21486 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21487 PyObject *resultobj = 0;
21488 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21489 bool result;
21490 void *argp1 = 0 ;
21491 int res1 = 0 ;
21492 PyObject *swig_obj[1] ;
21493
21494 if (!args) SWIG_fail;
21495 swig_obj[0] = args;
21496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21497 if (!SWIG_IsOK(res1)) {
21498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21499 }
21500 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21501 result = (bool) ((arg1)->m_altDown);
21502 {
21503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21504 }
21505 return resultobj;
21506 fail:
21507 return NULL;
21508 }
21509
21510
21511 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21512 PyObject *resultobj = 0;
21513 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21514 bool arg2 ;
21515 void *argp1 = 0 ;
21516 int res1 = 0 ;
21517 bool val2 ;
21518 int ecode2 = 0 ;
21519 PyObject *swig_obj[2] ;
21520
21521 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21523 if (!SWIG_IsOK(res1)) {
21524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21525 }
21526 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21527 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21528 if (!SWIG_IsOK(ecode2)) {
21529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21530 }
21531 arg2 = static_cast< bool >(val2);
21532 if (arg1) (arg1)->m_metaDown = arg2;
21533
21534 resultobj = SWIG_Py_Void();
21535 return resultobj;
21536 fail:
21537 return NULL;
21538 }
21539
21540
21541 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21542 PyObject *resultobj = 0;
21543 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21544 bool result;
21545 void *argp1 = 0 ;
21546 int res1 = 0 ;
21547 PyObject *swig_obj[1] ;
21548
21549 if (!args) SWIG_fail;
21550 swig_obj[0] = args;
21551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21552 if (!SWIG_IsOK(res1)) {
21553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21554 }
21555 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21556 result = (bool) ((arg1)->m_metaDown);
21557 {
21558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21559 }
21560 return resultobj;
21561 fail:
21562 return NULL;
21563 }
21564
21565
21566 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21567 PyObject *resultobj = 0;
21568 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21569 int arg2 ;
21570 void *argp1 = 0 ;
21571 int res1 = 0 ;
21572 int val2 ;
21573 int ecode2 = 0 ;
21574 PyObject *swig_obj[2] ;
21575
21576 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21578 if (!SWIG_IsOK(res1)) {
21579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21580 }
21581 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21582 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21583 if (!SWIG_IsOK(ecode2)) {
21584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21585 }
21586 arg2 = static_cast< int >(val2);
21587 if (arg1) (arg1)->m_wheelRotation = arg2;
21588
21589 resultobj = SWIG_Py_Void();
21590 return resultobj;
21591 fail:
21592 return NULL;
21593 }
21594
21595
21596 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21597 PyObject *resultobj = 0;
21598 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21599 int result;
21600 void *argp1 = 0 ;
21601 int res1 = 0 ;
21602 PyObject *swig_obj[1] ;
21603
21604 if (!args) SWIG_fail;
21605 swig_obj[0] = args;
21606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21607 if (!SWIG_IsOK(res1)) {
21608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21609 }
21610 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21611 result = (int) ((arg1)->m_wheelRotation);
21612 resultobj = SWIG_From_int(static_cast< int >(result));
21613 return resultobj;
21614 fail:
21615 return NULL;
21616 }
21617
21618
21619 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21620 PyObject *resultobj = 0;
21621 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21622 int arg2 ;
21623 void *argp1 = 0 ;
21624 int res1 = 0 ;
21625 int val2 ;
21626 int ecode2 = 0 ;
21627 PyObject *swig_obj[2] ;
21628
21629 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21631 if (!SWIG_IsOK(res1)) {
21632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21633 }
21634 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21635 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21636 if (!SWIG_IsOK(ecode2)) {
21637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21638 }
21639 arg2 = static_cast< int >(val2);
21640 if (arg1) (arg1)->m_wheelDelta = arg2;
21641
21642 resultobj = SWIG_Py_Void();
21643 return resultobj;
21644 fail:
21645 return NULL;
21646 }
21647
21648
21649 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21650 PyObject *resultobj = 0;
21651 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21652 int result;
21653 void *argp1 = 0 ;
21654 int res1 = 0 ;
21655 PyObject *swig_obj[1] ;
21656
21657 if (!args) SWIG_fail;
21658 swig_obj[0] = args;
21659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21660 if (!SWIG_IsOK(res1)) {
21661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21662 }
21663 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21664 result = (int) ((arg1)->m_wheelDelta);
21665 resultobj = SWIG_From_int(static_cast< int >(result));
21666 return resultobj;
21667 fail:
21668 return NULL;
21669 }
21670
21671
21672 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21673 PyObject *resultobj = 0;
21674 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21675 int arg2 ;
21676 void *argp1 = 0 ;
21677 int res1 = 0 ;
21678 int val2 ;
21679 int ecode2 = 0 ;
21680 PyObject *swig_obj[2] ;
21681
21682 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21684 if (!SWIG_IsOK(res1)) {
21685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21686 }
21687 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21688 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21689 if (!SWIG_IsOK(ecode2)) {
21690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21691 }
21692 arg2 = static_cast< int >(val2);
21693 if (arg1) (arg1)->m_linesPerAction = arg2;
21694
21695 resultobj = SWIG_Py_Void();
21696 return resultobj;
21697 fail:
21698 return NULL;
21699 }
21700
21701
21702 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21703 PyObject *resultobj = 0;
21704 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21705 int result;
21706 void *argp1 = 0 ;
21707 int res1 = 0 ;
21708 PyObject *swig_obj[1] ;
21709
21710 if (!args) SWIG_fail;
21711 swig_obj[0] = args;
21712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21713 if (!SWIG_IsOK(res1)) {
21714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21715 }
21716 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21717 result = (int) ((arg1)->m_linesPerAction);
21718 resultobj = SWIG_From_int(static_cast< int >(result));
21719 return resultobj;
21720 fail:
21721 return NULL;
21722 }
21723
21724
21725 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21726 PyObject *obj;
21727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21728 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21729 return SWIG_Py_Void();
21730 }
21731
21732 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21733 return SWIG_Python_InitShadowInstance(args);
21734 }
21735
21736 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21737 PyObject *resultobj = 0;
21738 int arg1 = (int) 0 ;
21739 int arg2 = (int) 0 ;
21740 wxSetCursorEvent *result = 0 ;
21741 int val1 ;
21742 int ecode1 = 0 ;
21743 int val2 ;
21744 int ecode2 = 0 ;
21745 PyObject * obj0 = 0 ;
21746 PyObject * obj1 = 0 ;
21747 char * kwnames[] = {
21748 (char *) "x",(char *) "y", NULL
21749 };
21750
21751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21752 if (obj0) {
21753 ecode1 = SWIG_AsVal_int(obj0, &val1);
21754 if (!SWIG_IsOK(ecode1)) {
21755 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21756 }
21757 arg1 = static_cast< int >(val1);
21758 }
21759 if (obj1) {
21760 ecode2 = SWIG_AsVal_int(obj1, &val2);
21761 if (!SWIG_IsOK(ecode2)) {
21762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21763 }
21764 arg2 = static_cast< int >(val2);
21765 }
21766 {
21767 PyThreadState* __tstate = wxPyBeginAllowThreads();
21768 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21769 wxPyEndAllowThreads(__tstate);
21770 if (PyErr_Occurred()) SWIG_fail;
21771 }
21772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21773 return resultobj;
21774 fail:
21775 return NULL;
21776 }
21777
21778
21779 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21780 PyObject *resultobj = 0;
21781 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21782 int result;
21783 void *argp1 = 0 ;
21784 int res1 = 0 ;
21785 PyObject *swig_obj[1] ;
21786
21787 if (!args) SWIG_fail;
21788 swig_obj[0] = args;
21789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21790 if (!SWIG_IsOK(res1)) {
21791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21792 }
21793 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21794 {
21795 PyThreadState* __tstate = wxPyBeginAllowThreads();
21796 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21797 wxPyEndAllowThreads(__tstate);
21798 if (PyErr_Occurred()) SWIG_fail;
21799 }
21800 resultobj = SWIG_From_int(static_cast< int >(result));
21801 return resultobj;
21802 fail:
21803 return NULL;
21804 }
21805
21806
21807 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21808 PyObject *resultobj = 0;
21809 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21810 int result;
21811 void *argp1 = 0 ;
21812 int res1 = 0 ;
21813 PyObject *swig_obj[1] ;
21814
21815 if (!args) SWIG_fail;
21816 swig_obj[0] = args;
21817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21818 if (!SWIG_IsOK(res1)) {
21819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21820 }
21821 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21822 {
21823 PyThreadState* __tstate = wxPyBeginAllowThreads();
21824 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21825 wxPyEndAllowThreads(__tstate);
21826 if (PyErr_Occurred()) SWIG_fail;
21827 }
21828 resultobj = SWIG_From_int(static_cast< int >(result));
21829 return resultobj;
21830 fail:
21831 return NULL;
21832 }
21833
21834
21835 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21836 PyObject *resultobj = 0;
21837 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21838 wxCursor *arg2 = 0 ;
21839 void *argp1 = 0 ;
21840 int res1 = 0 ;
21841 void *argp2 = 0 ;
21842 int res2 = 0 ;
21843 PyObject * obj0 = 0 ;
21844 PyObject * obj1 = 0 ;
21845 char * kwnames[] = {
21846 (char *) "self",(char *) "cursor", NULL
21847 };
21848
21849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21851 if (!SWIG_IsOK(res1)) {
21852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21853 }
21854 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21855 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21856 if (!SWIG_IsOK(res2)) {
21857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21858 }
21859 if (!argp2) {
21860 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21861 }
21862 arg2 = reinterpret_cast< wxCursor * >(argp2);
21863 {
21864 PyThreadState* __tstate = wxPyBeginAllowThreads();
21865 (arg1)->SetCursor((wxCursor const &)*arg2);
21866 wxPyEndAllowThreads(__tstate);
21867 if (PyErr_Occurred()) SWIG_fail;
21868 }
21869 resultobj = SWIG_Py_Void();
21870 return resultobj;
21871 fail:
21872 return NULL;
21873 }
21874
21875
21876 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21877 PyObject *resultobj = 0;
21878 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21879 wxCursor *result = 0 ;
21880 void *argp1 = 0 ;
21881 int res1 = 0 ;
21882 PyObject *swig_obj[1] ;
21883
21884 if (!args) SWIG_fail;
21885 swig_obj[0] = args;
21886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21887 if (!SWIG_IsOK(res1)) {
21888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21889 }
21890 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21891 {
21892 PyThreadState* __tstate = wxPyBeginAllowThreads();
21893 {
21894 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21895 result = (wxCursor *) &_result_ref;
21896 }
21897 wxPyEndAllowThreads(__tstate);
21898 if (PyErr_Occurred()) SWIG_fail;
21899 }
21900 {
21901 wxCursor* resultptr = new wxCursor(*result);
21902 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21903 }
21904 return resultobj;
21905 fail:
21906 return NULL;
21907 }
21908
21909
21910 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21911 PyObject *resultobj = 0;
21912 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21913 bool result;
21914 void *argp1 = 0 ;
21915 int res1 = 0 ;
21916 PyObject *swig_obj[1] ;
21917
21918 if (!args) SWIG_fail;
21919 swig_obj[0] = args;
21920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21921 if (!SWIG_IsOK(res1)) {
21922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21923 }
21924 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21925 {
21926 PyThreadState* __tstate = wxPyBeginAllowThreads();
21927 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21928 wxPyEndAllowThreads(__tstate);
21929 if (PyErr_Occurred()) SWIG_fail;
21930 }
21931 {
21932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21933 }
21934 return resultobj;
21935 fail:
21936 return NULL;
21937 }
21938
21939
21940 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21941 PyObject *obj;
21942 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21943 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21944 return SWIG_Py_Void();
21945 }
21946
21947 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21948 return SWIG_Python_InitShadowInstance(args);
21949 }
21950
21951 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21952 PyObject *resultobj = 0;
21953 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21954 wxKeyEvent *result = 0 ;
21955 int val1 ;
21956 int ecode1 = 0 ;
21957 PyObject * obj0 = 0 ;
21958 char * kwnames[] = {
21959 (char *) "eventType", NULL
21960 };
21961
21962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21963 if (obj0) {
21964 ecode1 = SWIG_AsVal_int(obj0, &val1);
21965 if (!SWIG_IsOK(ecode1)) {
21966 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21967 }
21968 arg1 = static_cast< wxEventType >(val1);
21969 }
21970 {
21971 PyThreadState* __tstate = wxPyBeginAllowThreads();
21972 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21973 wxPyEndAllowThreads(__tstate);
21974 if (PyErr_Occurred()) SWIG_fail;
21975 }
21976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21977 return resultobj;
21978 fail:
21979 return NULL;
21980 }
21981
21982
21983 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21984 PyObject *resultobj = 0;
21985 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21986 int result;
21987 void *argp1 = 0 ;
21988 int res1 = 0 ;
21989 PyObject *swig_obj[1] ;
21990
21991 if (!args) SWIG_fail;
21992 swig_obj[0] = args;
21993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21994 if (!SWIG_IsOK(res1)) {
21995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21996 }
21997 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21998 {
21999 PyThreadState* __tstate = wxPyBeginAllowThreads();
22000 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22001 wxPyEndAllowThreads(__tstate);
22002 if (PyErr_Occurred()) SWIG_fail;
22003 }
22004 resultobj = SWIG_From_int(static_cast< int >(result));
22005 return resultobj;
22006 fail:
22007 return NULL;
22008 }
22009
22010
22011 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22012 PyObject *resultobj = 0;
22013 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22014 bool result;
22015 void *argp1 = 0 ;
22016 int res1 = 0 ;
22017 PyObject *swig_obj[1] ;
22018
22019 if (!args) SWIG_fail;
22020 swig_obj[0] = args;
22021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22022 if (!SWIG_IsOK(res1)) {
22023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22024 }
22025 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22026 {
22027 PyThreadState* __tstate = wxPyBeginAllowThreads();
22028 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22029 wxPyEndAllowThreads(__tstate);
22030 if (PyErr_Occurred()) SWIG_fail;
22031 }
22032 {
22033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22034 }
22035 return resultobj;
22036 fail:
22037 return NULL;
22038 }
22039
22040
22041 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22042 PyObject *resultobj = 0;
22043 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22044 bool result;
22045 void *argp1 = 0 ;
22046 int res1 = 0 ;
22047 PyObject *swig_obj[1] ;
22048
22049 if (!args) SWIG_fail;
22050 swig_obj[0] = args;
22051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22052 if (!SWIG_IsOK(res1)) {
22053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22054 }
22055 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22056 {
22057 PyThreadState* __tstate = wxPyBeginAllowThreads();
22058 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22059 wxPyEndAllowThreads(__tstate);
22060 if (PyErr_Occurred()) SWIG_fail;
22061 }
22062 {
22063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22064 }
22065 return resultobj;
22066 fail:
22067 return NULL;
22068 }
22069
22070
22071 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22072 PyObject *resultobj = 0;
22073 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22074 bool result;
22075 void *argp1 = 0 ;
22076 int res1 = 0 ;
22077 PyObject *swig_obj[1] ;
22078
22079 if (!args) SWIG_fail;
22080 swig_obj[0] = args;
22081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22082 if (!SWIG_IsOK(res1)) {
22083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22084 }
22085 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22086 {
22087 PyThreadState* __tstate = wxPyBeginAllowThreads();
22088 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22089 wxPyEndAllowThreads(__tstate);
22090 if (PyErr_Occurred()) SWIG_fail;
22091 }
22092 {
22093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22094 }
22095 return resultobj;
22096 fail:
22097 return NULL;
22098 }
22099
22100
22101 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22102 PyObject *resultobj = 0;
22103 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22104 bool result;
22105 void *argp1 = 0 ;
22106 int res1 = 0 ;
22107 PyObject *swig_obj[1] ;
22108
22109 if (!args) SWIG_fail;
22110 swig_obj[0] = args;
22111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22112 if (!SWIG_IsOK(res1)) {
22113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22114 }
22115 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22116 {
22117 PyThreadState* __tstate = wxPyBeginAllowThreads();
22118 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22119 wxPyEndAllowThreads(__tstate);
22120 if (PyErr_Occurred()) SWIG_fail;
22121 }
22122 {
22123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22124 }
22125 return resultobj;
22126 fail:
22127 return NULL;
22128 }
22129
22130
22131 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22132 PyObject *resultobj = 0;
22133 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22134 bool result;
22135 void *argp1 = 0 ;
22136 int res1 = 0 ;
22137 PyObject *swig_obj[1] ;
22138
22139 if (!args) SWIG_fail;
22140 swig_obj[0] = args;
22141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22142 if (!SWIG_IsOK(res1)) {
22143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22144 }
22145 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22146 {
22147 PyThreadState* __tstate = wxPyBeginAllowThreads();
22148 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22149 wxPyEndAllowThreads(__tstate);
22150 if (PyErr_Occurred()) SWIG_fail;
22151 }
22152 {
22153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22154 }
22155 return resultobj;
22156 fail:
22157 return NULL;
22158 }
22159
22160
22161 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22162 PyObject *resultobj = 0;
22163 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22164 bool result;
22165 void *argp1 = 0 ;
22166 int res1 = 0 ;
22167 PyObject *swig_obj[1] ;
22168
22169 if (!args) SWIG_fail;
22170 swig_obj[0] = args;
22171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22172 if (!SWIG_IsOK(res1)) {
22173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22174 }
22175 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22176 {
22177 PyThreadState* __tstate = wxPyBeginAllowThreads();
22178 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22179 wxPyEndAllowThreads(__tstate);
22180 if (PyErr_Occurred()) SWIG_fail;
22181 }
22182 {
22183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22184 }
22185 return resultobj;
22186 fail:
22187 return NULL;
22188 }
22189
22190
22191 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22192 PyObject *resultobj = 0;
22193 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22194 int result;
22195 void *argp1 = 0 ;
22196 int res1 = 0 ;
22197 PyObject *swig_obj[1] ;
22198
22199 if (!args) SWIG_fail;
22200 swig_obj[0] = args;
22201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22202 if (!SWIG_IsOK(res1)) {
22203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22204 }
22205 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22206 {
22207 PyThreadState* __tstate = wxPyBeginAllowThreads();
22208 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22209 wxPyEndAllowThreads(__tstate);
22210 if (PyErr_Occurred()) SWIG_fail;
22211 }
22212 resultobj = SWIG_From_int(static_cast< int >(result));
22213 return resultobj;
22214 fail:
22215 return NULL;
22216 }
22217
22218
22219 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22220 PyObject *resultobj = 0;
22221 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22222 int result;
22223 void *argp1 = 0 ;
22224 int res1 = 0 ;
22225 PyObject *swig_obj[1] ;
22226
22227 if (!args) SWIG_fail;
22228 swig_obj[0] = args;
22229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22230 if (!SWIG_IsOK(res1)) {
22231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22232 }
22233 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22234 {
22235 PyThreadState* __tstate = wxPyBeginAllowThreads();
22236 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22237 wxPyEndAllowThreads(__tstate);
22238 if (PyErr_Occurred()) SWIG_fail;
22239 }
22240 resultobj = SWIG_From_int(static_cast< int >(result));
22241 return resultobj;
22242 fail:
22243 return NULL;
22244 }
22245
22246
22247 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22248 PyObject *resultobj = 0;
22249 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22250 int arg2 ;
22251 void *argp1 = 0 ;
22252 int res1 = 0 ;
22253 int val2 ;
22254 int ecode2 = 0 ;
22255 PyObject * obj0 = 0 ;
22256 PyObject * obj1 = 0 ;
22257 char * kwnames[] = {
22258 (char *) "self",(char *) "uniChar", NULL
22259 };
22260
22261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22263 if (!SWIG_IsOK(res1)) {
22264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22265 }
22266 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22267 ecode2 = SWIG_AsVal_int(obj1, &val2);
22268 if (!SWIG_IsOK(ecode2)) {
22269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22270 }
22271 arg2 = static_cast< int >(val2);
22272 {
22273 PyThreadState* __tstate = wxPyBeginAllowThreads();
22274 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22275 wxPyEndAllowThreads(__tstate);
22276 if (PyErr_Occurred()) SWIG_fail;
22277 }
22278 resultobj = SWIG_Py_Void();
22279 return resultobj;
22280 fail:
22281 return NULL;
22282 }
22283
22284
22285 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22286 PyObject *resultobj = 0;
22287 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22288 unsigned int result;
22289 void *argp1 = 0 ;
22290 int res1 = 0 ;
22291 PyObject *swig_obj[1] ;
22292
22293 if (!args) SWIG_fail;
22294 swig_obj[0] = args;
22295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22296 if (!SWIG_IsOK(res1)) {
22297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22298 }
22299 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22300 {
22301 PyThreadState* __tstate = wxPyBeginAllowThreads();
22302 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22303 wxPyEndAllowThreads(__tstate);
22304 if (PyErr_Occurred()) SWIG_fail;
22305 }
22306 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22307 return resultobj;
22308 fail:
22309 return NULL;
22310 }
22311
22312
22313 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22314 PyObject *resultobj = 0;
22315 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22316 unsigned int 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_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22326 }
22327 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22328 {
22329 PyThreadState* __tstate = wxPyBeginAllowThreads();
22330 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22331 wxPyEndAllowThreads(__tstate);
22332 if (PyErr_Occurred()) SWIG_fail;
22333 }
22334 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22335 return resultobj;
22336 fail:
22337 return NULL;
22338 }
22339
22340
22341 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22342 PyObject *resultobj = 0;
22343 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22344 wxPoint result;
22345 void *argp1 = 0 ;
22346 int res1 = 0 ;
22347 PyObject *swig_obj[1] ;
22348
22349 if (!args) SWIG_fail;
22350 swig_obj[0] = args;
22351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22352 if (!SWIG_IsOK(res1)) {
22353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22354 }
22355 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22356 {
22357 PyThreadState* __tstate = wxPyBeginAllowThreads();
22358 result = (arg1)->GetPosition();
22359 wxPyEndAllowThreads(__tstate);
22360 if (PyErr_Occurred()) SWIG_fail;
22361 }
22362 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22363 return resultobj;
22364 fail:
22365 return NULL;
22366 }
22367
22368
22369 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22370 PyObject *resultobj = 0;
22371 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22372 long *arg2 = (long *) 0 ;
22373 long *arg3 = (long *) 0 ;
22374 void *argp1 = 0 ;
22375 int res1 = 0 ;
22376 long temp2 ;
22377 int res2 = SWIG_TMPOBJ ;
22378 long temp3 ;
22379 int res3 = SWIG_TMPOBJ ;
22380 PyObject *swig_obj[1] ;
22381
22382 arg2 = &temp2;
22383 arg3 = &temp3;
22384 if (!args) SWIG_fail;
22385 swig_obj[0] = args;
22386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22387 if (!SWIG_IsOK(res1)) {
22388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22389 }
22390 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22391 {
22392 PyThreadState* __tstate = wxPyBeginAllowThreads();
22393 (arg1)->GetPosition(arg2,arg3);
22394 wxPyEndAllowThreads(__tstate);
22395 if (PyErr_Occurred()) SWIG_fail;
22396 }
22397 resultobj = SWIG_Py_Void();
22398 if (SWIG_IsTmpObj(res2)) {
22399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22400 } else {
22401 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22402 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22403 }
22404 if (SWIG_IsTmpObj(res3)) {
22405 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22406 } else {
22407 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22408 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22409 }
22410 return resultobj;
22411 fail:
22412 return NULL;
22413 }
22414
22415
22416 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22417 PyObject *resultobj = 0;
22418 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22419 int result;
22420 void *argp1 = 0 ;
22421 int res1 = 0 ;
22422 PyObject *swig_obj[1] ;
22423
22424 if (!args) SWIG_fail;
22425 swig_obj[0] = args;
22426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22427 if (!SWIG_IsOK(res1)) {
22428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22429 }
22430 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22431 {
22432 PyThreadState* __tstate = wxPyBeginAllowThreads();
22433 result = (int)((wxKeyEvent const *)arg1)->GetX();
22434 wxPyEndAllowThreads(__tstate);
22435 if (PyErr_Occurred()) SWIG_fail;
22436 }
22437 resultobj = SWIG_From_int(static_cast< int >(result));
22438 return resultobj;
22439 fail:
22440 return NULL;
22441 }
22442
22443
22444 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22445 PyObject *resultobj = 0;
22446 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22447 int result;
22448 void *argp1 = 0 ;
22449 int res1 = 0 ;
22450 PyObject *swig_obj[1] ;
22451
22452 if (!args) SWIG_fail;
22453 swig_obj[0] = args;
22454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22455 if (!SWIG_IsOK(res1)) {
22456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22457 }
22458 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22459 {
22460 PyThreadState* __tstate = wxPyBeginAllowThreads();
22461 result = (int)((wxKeyEvent const *)arg1)->GetY();
22462 wxPyEndAllowThreads(__tstate);
22463 if (PyErr_Occurred()) SWIG_fail;
22464 }
22465 resultobj = SWIG_From_int(static_cast< int >(result));
22466 return resultobj;
22467 fail:
22468 return NULL;
22469 }
22470
22471
22472 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22473 PyObject *resultobj = 0;
22474 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22475 int arg2 ;
22476 void *argp1 = 0 ;
22477 int res1 = 0 ;
22478 int val2 ;
22479 int ecode2 = 0 ;
22480 PyObject *swig_obj[2] ;
22481
22482 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22484 if (!SWIG_IsOK(res1)) {
22485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22486 }
22487 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22488 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22489 if (!SWIG_IsOK(ecode2)) {
22490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22491 }
22492 arg2 = static_cast< int >(val2);
22493 if (arg1) (arg1)->m_x = arg2;
22494
22495 resultobj = SWIG_Py_Void();
22496 return resultobj;
22497 fail:
22498 return NULL;
22499 }
22500
22501
22502 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22503 PyObject *resultobj = 0;
22504 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22505 int result;
22506 void *argp1 = 0 ;
22507 int res1 = 0 ;
22508 PyObject *swig_obj[1] ;
22509
22510 if (!args) SWIG_fail;
22511 swig_obj[0] = args;
22512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22513 if (!SWIG_IsOK(res1)) {
22514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22515 }
22516 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22517 result = (int) ((arg1)->m_x);
22518 resultobj = SWIG_From_int(static_cast< int >(result));
22519 return resultobj;
22520 fail:
22521 return NULL;
22522 }
22523
22524
22525 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22526 PyObject *resultobj = 0;
22527 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22528 int arg2 ;
22529 void *argp1 = 0 ;
22530 int res1 = 0 ;
22531 int val2 ;
22532 int ecode2 = 0 ;
22533 PyObject *swig_obj[2] ;
22534
22535 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22537 if (!SWIG_IsOK(res1)) {
22538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22539 }
22540 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22541 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22542 if (!SWIG_IsOK(ecode2)) {
22543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22544 }
22545 arg2 = static_cast< int >(val2);
22546 if (arg1) (arg1)->m_y = arg2;
22547
22548 resultobj = SWIG_Py_Void();
22549 return resultobj;
22550 fail:
22551 return NULL;
22552 }
22553
22554
22555 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22556 PyObject *resultobj = 0;
22557 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22558 int result;
22559 void *argp1 = 0 ;
22560 int res1 = 0 ;
22561 PyObject *swig_obj[1] ;
22562
22563 if (!args) SWIG_fail;
22564 swig_obj[0] = args;
22565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22566 if (!SWIG_IsOK(res1)) {
22567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22568 }
22569 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22570 result = (int) ((arg1)->m_y);
22571 resultobj = SWIG_From_int(static_cast< int >(result));
22572 return resultobj;
22573 fail:
22574 return NULL;
22575 }
22576
22577
22578 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22579 PyObject *resultobj = 0;
22580 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22581 long arg2 ;
22582 void *argp1 = 0 ;
22583 int res1 = 0 ;
22584 long val2 ;
22585 int ecode2 = 0 ;
22586 PyObject *swig_obj[2] ;
22587
22588 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22590 if (!SWIG_IsOK(res1)) {
22591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22592 }
22593 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22594 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22595 if (!SWIG_IsOK(ecode2)) {
22596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22597 }
22598 arg2 = static_cast< long >(val2);
22599 if (arg1) (arg1)->m_keyCode = arg2;
22600
22601 resultobj = SWIG_Py_Void();
22602 return resultobj;
22603 fail:
22604 return NULL;
22605 }
22606
22607
22608 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22609 PyObject *resultobj = 0;
22610 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22611 long result;
22612 void *argp1 = 0 ;
22613 int res1 = 0 ;
22614 PyObject *swig_obj[1] ;
22615
22616 if (!args) SWIG_fail;
22617 swig_obj[0] = args;
22618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22619 if (!SWIG_IsOK(res1)) {
22620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22621 }
22622 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22623 result = (long) ((arg1)->m_keyCode);
22624 resultobj = SWIG_From_long(static_cast< long >(result));
22625 return resultobj;
22626 fail:
22627 return NULL;
22628 }
22629
22630
22631 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22632 PyObject *resultobj = 0;
22633 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22634 bool arg2 ;
22635 void *argp1 = 0 ;
22636 int res1 = 0 ;
22637 bool val2 ;
22638 int ecode2 = 0 ;
22639 PyObject *swig_obj[2] ;
22640
22641 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22643 if (!SWIG_IsOK(res1)) {
22644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22645 }
22646 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22647 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22648 if (!SWIG_IsOK(ecode2)) {
22649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22650 }
22651 arg2 = static_cast< bool >(val2);
22652 if (arg1) (arg1)->m_controlDown = arg2;
22653
22654 resultobj = SWIG_Py_Void();
22655 return resultobj;
22656 fail:
22657 return NULL;
22658 }
22659
22660
22661 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22662 PyObject *resultobj = 0;
22663 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22664 bool result;
22665 void *argp1 = 0 ;
22666 int res1 = 0 ;
22667 PyObject *swig_obj[1] ;
22668
22669 if (!args) SWIG_fail;
22670 swig_obj[0] = args;
22671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22672 if (!SWIG_IsOK(res1)) {
22673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22674 }
22675 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22676 result = (bool) ((arg1)->m_controlDown);
22677 {
22678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22679 }
22680 return resultobj;
22681 fail:
22682 return NULL;
22683 }
22684
22685
22686 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22687 PyObject *resultobj = 0;
22688 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22689 bool arg2 ;
22690 void *argp1 = 0 ;
22691 int res1 = 0 ;
22692 bool val2 ;
22693 int ecode2 = 0 ;
22694 PyObject *swig_obj[2] ;
22695
22696 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22698 if (!SWIG_IsOK(res1)) {
22699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22700 }
22701 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22702 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22703 if (!SWIG_IsOK(ecode2)) {
22704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22705 }
22706 arg2 = static_cast< bool >(val2);
22707 if (arg1) (arg1)->m_shiftDown = arg2;
22708
22709 resultobj = SWIG_Py_Void();
22710 return resultobj;
22711 fail:
22712 return NULL;
22713 }
22714
22715
22716 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22717 PyObject *resultobj = 0;
22718 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22719 bool result;
22720 void *argp1 = 0 ;
22721 int res1 = 0 ;
22722 PyObject *swig_obj[1] ;
22723
22724 if (!args) SWIG_fail;
22725 swig_obj[0] = args;
22726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22727 if (!SWIG_IsOK(res1)) {
22728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22729 }
22730 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22731 result = (bool) ((arg1)->m_shiftDown);
22732 {
22733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22734 }
22735 return resultobj;
22736 fail:
22737 return NULL;
22738 }
22739
22740
22741 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22742 PyObject *resultobj = 0;
22743 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22744 bool arg2 ;
22745 void *argp1 = 0 ;
22746 int res1 = 0 ;
22747 bool val2 ;
22748 int ecode2 = 0 ;
22749 PyObject *swig_obj[2] ;
22750
22751 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22753 if (!SWIG_IsOK(res1)) {
22754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22755 }
22756 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22757 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22758 if (!SWIG_IsOK(ecode2)) {
22759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22760 }
22761 arg2 = static_cast< bool >(val2);
22762 if (arg1) (arg1)->m_altDown = arg2;
22763
22764 resultobj = SWIG_Py_Void();
22765 return resultobj;
22766 fail:
22767 return NULL;
22768 }
22769
22770
22771 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22772 PyObject *resultobj = 0;
22773 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22774 bool result;
22775 void *argp1 = 0 ;
22776 int res1 = 0 ;
22777 PyObject *swig_obj[1] ;
22778
22779 if (!args) SWIG_fail;
22780 swig_obj[0] = args;
22781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22782 if (!SWIG_IsOK(res1)) {
22783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22784 }
22785 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22786 result = (bool) ((arg1)->m_altDown);
22787 {
22788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22789 }
22790 return resultobj;
22791 fail:
22792 return NULL;
22793 }
22794
22795
22796 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22797 PyObject *resultobj = 0;
22798 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22799 bool arg2 ;
22800 void *argp1 = 0 ;
22801 int res1 = 0 ;
22802 bool val2 ;
22803 int ecode2 = 0 ;
22804 PyObject *swig_obj[2] ;
22805
22806 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22808 if (!SWIG_IsOK(res1)) {
22809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22810 }
22811 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22812 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22813 if (!SWIG_IsOK(ecode2)) {
22814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22815 }
22816 arg2 = static_cast< bool >(val2);
22817 if (arg1) (arg1)->m_metaDown = arg2;
22818
22819 resultobj = SWIG_Py_Void();
22820 return resultobj;
22821 fail:
22822 return NULL;
22823 }
22824
22825
22826 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22827 PyObject *resultobj = 0;
22828 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22829 bool result;
22830 void *argp1 = 0 ;
22831 int res1 = 0 ;
22832 PyObject *swig_obj[1] ;
22833
22834 if (!args) SWIG_fail;
22835 swig_obj[0] = args;
22836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22837 if (!SWIG_IsOK(res1)) {
22838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22839 }
22840 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22841 result = (bool) ((arg1)->m_metaDown);
22842 {
22843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22844 }
22845 return resultobj;
22846 fail:
22847 return NULL;
22848 }
22849
22850
22851 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22852 PyObject *resultobj = 0;
22853 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22854 bool arg2 ;
22855 void *argp1 = 0 ;
22856 int res1 = 0 ;
22857 bool val2 ;
22858 int ecode2 = 0 ;
22859 PyObject *swig_obj[2] ;
22860
22861 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22863 if (!SWIG_IsOK(res1)) {
22864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22865 }
22866 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22867 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22868 if (!SWIG_IsOK(ecode2)) {
22869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22870 }
22871 arg2 = static_cast< bool >(val2);
22872 if (arg1) (arg1)->m_scanCode = arg2;
22873
22874 resultobj = SWIG_Py_Void();
22875 return resultobj;
22876 fail:
22877 return NULL;
22878 }
22879
22880
22881 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22882 PyObject *resultobj = 0;
22883 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22884 bool result;
22885 void *argp1 = 0 ;
22886 int res1 = 0 ;
22887 PyObject *swig_obj[1] ;
22888
22889 if (!args) SWIG_fail;
22890 swig_obj[0] = args;
22891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22892 if (!SWIG_IsOK(res1)) {
22893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22894 }
22895 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22896 result = (bool) ((arg1)->m_scanCode);
22897 {
22898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22899 }
22900 return resultobj;
22901 fail:
22902 return NULL;
22903 }
22904
22905
22906 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22907 PyObject *resultobj = 0;
22908 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22909 unsigned int arg2 ;
22910 void *argp1 = 0 ;
22911 int res1 = 0 ;
22912 unsigned int val2 ;
22913 int ecode2 = 0 ;
22914 PyObject *swig_obj[2] ;
22915
22916 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22918 if (!SWIG_IsOK(res1)) {
22919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22920 }
22921 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22922 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22923 if (!SWIG_IsOK(ecode2)) {
22924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22925 }
22926 arg2 = static_cast< unsigned int >(val2);
22927 if (arg1) (arg1)->m_rawCode = arg2;
22928
22929 resultobj = SWIG_Py_Void();
22930 return resultobj;
22931 fail:
22932 return NULL;
22933 }
22934
22935
22936 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22937 PyObject *resultobj = 0;
22938 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22939 unsigned int result;
22940 void *argp1 = 0 ;
22941 int res1 = 0 ;
22942 PyObject *swig_obj[1] ;
22943
22944 if (!args) SWIG_fail;
22945 swig_obj[0] = args;
22946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22947 if (!SWIG_IsOK(res1)) {
22948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22949 }
22950 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22951 result = (unsigned int) ((arg1)->m_rawCode);
22952 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22953 return resultobj;
22954 fail:
22955 return NULL;
22956 }
22957
22958
22959 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22960 PyObject *resultobj = 0;
22961 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22962 unsigned int arg2 ;
22963 void *argp1 = 0 ;
22964 int res1 = 0 ;
22965 unsigned int val2 ;
22966 int ecode2 = 0 ;
22967 PyObject *swig_obj[2] ;
22968
22969 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22971 if (!SWIG_IsOK(res1)) {
22972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22973 }
22974 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22975 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22976 if (!SWIG_IsOK(ecode2)) {
22977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22978 }
22979 arg2 = static_cast< unsigned int >(val2);
22980 if (arg1) (arg1)->m_rawFlags = arg2;
22981
22982 resultobj = SWIG_Py_Void();
22983 return resultobj;
22984 fail:
22985 return NULL;
22986 }
22987
22988
22989 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22990 PyObject *resultobj = 0;
22991 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22992 unsigned int result;
22993 void *argp1 = 0 ;
22994 int res1 = 0 ;
22995 PyObject *swig_obj[1] ;
22996
22997 if (!args) SWIG_fail;
22998 swig_obj[0] = args;
22999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23000 if (!SWIG_IsOK(res1)) {
23001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23002 }
23003 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23004 result = (unsigned int) ((arg1)->m_rawFlags);
23005 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23006 return resultobj;
23007 fail:
23008 return NULL;
23009 }
23010
23011
23012 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23013 PyObject *obj;
23014 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23015 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23016 return SWIG_Py_Void();
23017 }
23018
23019 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23020 return SWIG_Python_InitShadowInstance(args);
23021 }
23022
23023 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23024 PyObject *resultobj = 0;
23025 wxSize const &arg1_defvalue = wxDefaultSize ;
23026 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23027 int arg2 = (int) 0 ;
23028 wxSizeEvent *result = 0 ;
23029 wxSize temp1 ;
23030 int val2 ;
23031 int ecode2 = 0 ;
23032 PyObject * obj0 = 0 ;
23033 PyObject * obj1 = 0 ;
23034 char * kwnames[] = {
23035 (char *) "sz",(char *) "winid", NULL
23036 };
23037
23038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23039 if (obj0) {
23040 {
23041 arg1 = &temp1;
23042 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23043 }
23044 }
23045 if (obj1) {
23046 ecode2 = SWIG_AsVal_int(obj1, &val2);
23047 if (!SWIG_IsOK(ecode2)) {
23048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23049 }
23050 arg2 = static_cast< int >(val2);
23051 }
23052 {
23053 PyThreadState* __tstate = wxPyBeginAllowThreads();
23054 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23055 wxPyEndAllowThreads(__tstate);
23056 if (PyErr_Occurred()) SWIG_fail;
23057 }
23058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23059 return resultobj;
23060 fail:
23061 return NULL;
23062 }
23063
23064
23065 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23066 PyObject *resultobj = 0;
23067 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23068 wxSize result;
23069 void *argp1 = 0 ;
23070 int res1 = 0 ;
23071 PyObject *swig_obj[1] ;
23072
23073 if (!args) SWIG_fail;
23074 swig_obj[0] = args;
23075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23076 if (!SWIG_IsOK(res1)) {
23077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23078 }
23079 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23080 {
23081 PyThreadState* __tstate = wxPyBeginAllowThreads();
23082 result = ((wxSizeEvent const *)arg1)->GetSize();
23083 wxPyEndAllowThreads(__tstate);
23084 if (PyErr_Occurred()) SWIG_fail;
23085 }
23086 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23087 return resultobj;
23088 fail:
23089 return NULL;
23090 }
23091
23092
23093 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23094 PyObject *resultobj = 0;
23095 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23096 wxRect 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_wxSizeEvent, 0 | 0 );
23104 if (!SWIG_IsOK(res1)) {
23105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23106 }
23107 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23108 {
23109 PyThreadState* __tstate = wxPyBeginAllowThreads();
23110 result = ((wxSizeEvent const *)arg1)->GetRect();
23111 wxPyEndAllowThreads(__tstate);
23112 if (PyErr_Occurred()) SWIG_fail;
23113 }
23114 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23115 return resultobj;
23116 fail:
23117 return NULL;
23118 }
23119
23120
23121 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23122 PyObject *resultobj = 0;
23123 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23124 wxRect arg2 ;
23125 void *argp1 = 0 ;
23126 int res1 = 0 ;
23127 void *argp2 ;
23128 int res2 = 0 ;
23129 PyObject * obj0 = 0 ;
23130 PyObject * obj1 = 0 ;
23131 char * kwnames[] = {
23132 (char *) "self",(char *) "rect", NULL
23133 };
23134
23135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23137 if (!SWIG_IsOK(res1)) {
23138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23139 }
23140 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23141 {
23142 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23143 if (!SWIG_IsOK(res2)) {
23144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23145 }
23146 if (!argp2) {
23147 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23148 } else {
23149 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23150 arg2 = *temp;
23151 if (SWIG_IsNewObj(res2)) delete temp;
23152 }
23153 }
23154 {
23155 PyThreadState* __tstate = wxPyBeginAllowThreads();
23156 (arg1)->SetRect(arg2);
23157 wxPyEndAllowThreads(__tstate);
23158 if (PyErr_Occurred()) SWIG_fail;
23159 }
23160 resultobj = SWIG_Py_Void();
23161 return resultobj;
23162 fail:
23163 return NULL;
23164 }
23165
23166
23167 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23168 PyObject *resultobj = 0;
23169 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23170 wxSize arg2 ;
23171 void *argp1 = 0 ;
23172 int res1 = 0 ;
23173 void *argp2 ;
23174 int res2 = 0 ;
23175 PyObject * obj0 = 0 ;
23176 PyObject * obj1 = 0 ;
23177 char * kwnames[] = {
23178 (char *) "self",(char *) "size", NULL
23179 };
23180
23181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23183 if (!SWIG_IsOK(res1)) {
23184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23185 }
23186 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23187 {
23188 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23189 if (!SWIG_IsOK(res2)) {
23190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23191 }
23192 if (!argp2) {
23193 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23194 } else {
23195 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23196 arg2 = *temp;
23197 if (SWIG_IsNewObj(res2)) delete temp;
23198 }
23199 }
23200 {
23201 PyThreadState* __tstate = wxPyBeginAllowThreads();
23202 wxSizeEvent_SetSize(arg1,arg2);
23203 wxPyEndAllowThreads(__tstate);
23204 if (PyErr_Occurred()) SWIG_fail;
23205 }
23206 resultobj = SWIG_Py_Void();
23207 return resultobj;
23208 fail:
23209 return NULL;
23210 }
23211
23212
23213 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23214 PyObject *resultobj = 0;
23215 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23216 wxSize *arg2 = (wxSize *) 0 ;
23217 void *argp1 = 0 ;
23218 int res1 = 0 ;
23219 void *argp2 = 0 ;
23220 int res2 = 0 ;
23221 PyObject *swig_obj[2] ;
23222
23223 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23225 if (!SWIG_IsOK(res1)) {
23226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23227 }
23228 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23229 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23230 if (!SWIG_IsOK(res2)) {
23231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23232 }
23233 arg2 = reinterpret_cast< wxSize * >(argp2);
23234 if (arg1) (arg1)->m_size = *arg2;
23235
23236 resultobj = SWIG_Py_Void();
23237 return resultobj;
23238 fail:
23239 return NULL;
23240 }
23241
23242
23243 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23244 PyObject *resultobj = 0;
23245 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23246 wxSize *result = 0 ;
23247 void *argp1 = 0 ;
23248 int res1 = 0 ;
23249 PyObject *swig_obj[1] ;
23250
23251 if (!args) SWIG_fail;
23252 swig_obj[0] = args;
23253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23254 if (!SWIG_IsOK(res1)) {
23255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23256 }
23257 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23258 result = (wxSize *)& ((arg1)->m_size);
23259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23260 return resultobj;
23261 fail:
23262 return NULL;
23263 }
23264
23265
23266 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23267 PyObject *resultobj = 0;
23268 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23269 wxRect *arg2 = (wxRect *) 0 ;
23270 void *argp1 = 0 ;
23271 int res1 = 0 ;
23272 void *argp2 = 0 ;
23273 int res2 = 0 ;
23274 PyObject *swig_obj[2] ;
23275
23276 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23278 if (!SWIG_IsOK(res1)) {
23279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23280 }
23281 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23282 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23283 if (!SWIG_IsOK(res2)) {
23284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23285 }
23286 arg2 = reinterpret_cast< wxRect * >(argp2);
23287 if (arg1) (arg1)->m_rect = *arg2;
23288
23289 resultobj = SWIG_Py_Void();
23290 return resultobj;
23291 fail:
23292 return NULL;
23293 }
23294
23295
23296 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23297 PyObject *resultobj = 0;
23298 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23299 wxRect *result = 0 ;
23300 void *argp1 = 0 ;
23301 int res1 = 0 ;
23302 PyObject *swig_obj[1] ;
23303
23304 if (!args) SWIG_fail;
23305 swig_obj[0] = args;
23306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23307 if (!SWIG_IsOK(res1)) {
23308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23309 }
23310 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23311 result = (wxRect *)& ((arg1)->m_rect);
23312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23313 return resultobj;
23314 fail:
23315 return NULL;
23316 }
23317
23318
23319 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23320 PyObject *obj;
23321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23322 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23323 return SWIG_Py_Void();
23324 }
23325
23326 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23327 return SWIG_Python_InitShadowInstance(args);
23328 }
23329
23330 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23331 PyObject *resultobj = 0;
23332 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23333 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23334 int arg2 = (int) 0 ;
23335 wxMoveEvent *result = 0 ;
23336 wxPoint temp1 ;
23337 int val2 ;
23338 int ecode2 = 0 ;
23339 PyObject * obj0 = 0 ;
23340 PyObject * obj1 = 0 ;
23341 char * kwnames[] = {
23342 (char *) "pos",(char *) "winid", NULL
23343 };
23344
23345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23346 if (obj0) {
23347 {
23348 arg1 = &temp1;
23349 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23350 }
23351 }
23352 if (obj1) {
23353 ecode2 = SWIG_AsVal_int(obj1, &val2);
23354 if (!SWIG_IsOK(ecode2)) {
23355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23356 }
23357 arg2 = static_cast< int >(val2);
23358 }
23359 {
23360 PyThreadState* __tstate = wxPyBeginAllowThreads();
23361 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23362 wxPyEndAllowThreads(__tstate);
23363 if (PyErr_Occurred()) SWIG_fail;
23364 }
23365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23366 return resultobj;
23367 fail:
23368 return NULL;
23369 }
23370
23371
23372 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23373 PyObject *resultobj = 0;
23374 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23375 wxPoint result;
23376 void *argp1 = 0 ;
23377 int res1 = 0 ;
23378 PyObject *swig_obj[1] ;
23379
23380 if (!args) SWIG_fail;
23381 swig_obj[0] = args;
23382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23383 if (!SWIG_IsOK(res1)) {
23384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23385 }
23386 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23387 {
23388 PyThreadState* __tstate = wxPyBeginAllowThreads();
23389 result = ((wxMoveEvent const *)arg1)->GetPosition();
23390 wxPyEndAllowThreads(__tstate);
23391 if (PyErr_Occurred()) SWIG_fail;
23392 }
23393 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23394 return resultobj;
23395 fail:
23396 return NULL;
23397 }
23398
23399
23400 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23401 PyObject *resultobj = 0;
23402 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23403 wxRect result;
23404 void *argp1 = 0 ;
23405 int res1 = 0 ;
23406 PyObject *swig_obj[1] ;
23407
23408 if (!args) SWIG_fail;
23409 swig_obj[0] = args;
23410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23411 if (!SWIG_IsOK(res1)) {
23412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23413 }
23414 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23415 {
23416 PyThreadState* __tstate = wxPyBeginAllowThreads();
23417 result = ((wxMoveEvent const *)arg1)->GetRect();
23418 wxPyEndAllowThreads(__tstate);
23419 if (PyErr_Occurred()) SWIG_fail;
23420 }
23421 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23422 return resultobj;
23423 fail:
23424 return NULL;
23425 }
23426
23427
23428 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23429 PyObject *resultobj = 0;
23430 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23431 wxRect *arg2 = 0 ;
23432 void *argp1 = 0 ;
23433 int res1 = 0 ;
23434 wxRect temp2 ;
23435 PyObject * obj0 = 0 ;
23436 PyObject * obj1 = 0 ;
23437 char * kwnames[] = {
23438 (char *) "self",(char *) "rect", NULL
23439 };
23440
23441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23443 if (!SWIG_IsOK(res1)) {
23444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23445 }
23446 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23447 {
23448 arg2 = &temp2;
23449 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23450 }
23451 {
23452 PyThreadState* __tstate = wxPyBeginAllowThreads();
23453 (arg1)->SetRect((wxRect const &)*arg2);
23454 wxPyEndAllowThreads(__tstate);
23455 if (PyErr_Occurred()) SWIG_fail;
23456 }
23457 resultobj = SWIG_Py_Void();
23458 return resultobj;
23459 fail:
23460 return NULL;
23461 }
23462
23463
23464 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23465 PyObject *resultobj = 0;
23466 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23467 wxPoint *arg2 = 0 ;
23468 void *argp1 = 0 ;
23469 int res1 = 0 ;
23470 wxPoint temp2 ;
23471 PyObject * obj0 = 0 ;
23472 PyObject * obj1 = 0 ;
23473 char * kwnames[] = {
23474 (char *) "self",(char *) "pos", NULL
23475 };
23476
23477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23479 if (!SWIG_IsOK(res1)) {
23480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23481 }
23482 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23483 {
23484 arg2 = &temp2;
23485 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23486 }
23487 {
23488 PyThreadState* __tstate = wxPyBeginAllowThreads();
23489 (arg1)->SetPosition((wxPoint const &)*arg2);
23490 wxPyEndAllowThreads(__tstate);
23491 if (PyErr_Occurred()) SWIG_fail;
23492 }
23493 resultobj = SWIG_Py_Void();
23494 return resultobj;
23495 fail:
23496 return NULL;
23497 }
23498
23499
23500 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23501 PyObject *obj;
23502 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23503 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23504 return SWIG_Py_Void();
23505 }
23506
23507 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23508 return SWIG_Python_InitShadowInstance(args);
23509 }
23510
23511 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23512 PyObject *resultobj = 0;
23513 int arg1 = (int) 0 ;
23514 wxPaintEvent *result = 0 ;
23515 int val1 ;
23516 int ecode1 = 0 ;
23517 PyObject * obj0 = 0 ;
23518 char * kwnames[] = {
23519 (char *) "Id", NULL
23520 };
23521
23522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23523 if (obj0) {
23524 ecode1 = SWIG_AsVal_int(obj0, &val1);
23525 if (!SWIG_IsOK(ecode1)) {
23526 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23527 }
23528 arg1 = static_cast< int >(val1);
23529 }
23530 {
23531 PyThreadState* __tstate = wxPyBeginAllowThreads();
23532 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23533 wxPyEndAllowThreads(__tstate);
23534 if (PyErr_Occurred()) SWIG_fail;
23535 }
23536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23537 return resultobj;
23538 fail:
23539 return NULL;
23540 }
23541
23542
23543 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23544 PyObject *obj;
23545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23546 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23547 return SWIG_Py_Void();
23548 }
23549
23550 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23551 return SWIG_Python_InitShadowInstance(args);
23552 }
23553
23554 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23555 PyObject *resultobj = 0;
23556 int arg1 = (int) 0 ;
23557 wxNcPaintEvent *result = 0 ;
23558 int val1 ;
23559 int ecode1 = 0 ;
23560 PyObject * obj0 = 0 ;
23561 char * kwnames[] = {
23562 (char *) "winid", NULL
23563 };
23564
23565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23566 if (obj0) {
23567 ecode1 = SWIG_AsVal_int(obj0, &val1);
23568 if (!SWIG_IsOK(ecode1)) {
23569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23570 }
23571 arg1 = static_cast< int >(val1);
23572 }
23573 {
23574 PyThreadState* __tstate = wxPyBeginAllowThreads();
23575 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23576 wxPyEndAllowThreads(__tstate);
23577 if (PyErr_Occurred()) SWIG_fail;
23578 }
23579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23580 return resultobj;
23581 fail:
23582 return NULL;
23583 }
23584
23585
23586 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23587 PyObject *obj;
23588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23589 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23590 return SWIG_Py_Void();
23591 }
23592
23593 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23594 return SWIG_Python_InitShadowInstance(args);
23595 }
23596
23597 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23598 PyObject *resultobj = 0;
23599 int arg1 = (int) 0 ;
23600 wxDC *arg2 = (wxDC *) NULL ;
23601 wxEraseEvent *result = 0 ;
23602 int val1 ;
23603 int ecode1 = 0 ;
23604 void *argp2 = 0 ;
23605 int res2 = 0 ;
23606 PyObject * obj0 = 0 ;
23607 PyObject * obj1 = 0 ;
23608 char * kwnames[] = {
23609 (char *) "Id",(char *) "dc", NULL
23610 };
23611
23612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23613 if (obj0) {
23614 ecode1 = SWIG_AsVal_int(obj0, &val1);
23615 if (!SWIG_IsOK(ecode1)) {
23616 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23617 }
23618 arg1 = static_cast< int >(val1);
23619 }
23620 if (obj1) {
23621 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23622 if (!SWIG_IsOK(res2)) {
23623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23624 }
23625 arg2 = reinterpret_cast< wxDC * >(argp2);
23626 }
23627 {
23628 PyThreadState* __tstate = wxPyBeginAllowThreads();
23629 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23630 wxPyEndAllowThreads(__tstate);
23631 if (PyErr_Occurred()) SWIG_fail;
23632 }
23633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23634 return resultobj;
23635 fail:
23636 return NULL;
23637 }
23638
23639
23640 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23641 PyObject *resultobj = 0;
23642 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23643 wxDC *result = 0 ;
23644 void *argp1 = 0 ;
23645 int res1 = 0 ;
23646 PyObject *swig_obj[1] ;
23647
23648 if (!args) SWIG_fail;
23649 swig_obj[0] = args;
23650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23651 if (!SWIG_IsOK(res1)) {
23652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23653 }
23654 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23655 {
23656 PyThreadState* __tstate = wxPyBeginAllowThreads();
23657 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23658 wxPyEndAllowThreads(__tstate);
23659 if (PyErr_Occurred()) SWIG_fail;
23660 }
23661 {
23662 resultobj = wxPyMake_wxObject(result, (bool)0);
23663 }
23664 return resultobj;
23665 fail:
23666 return NULL;
23667 }
23668
23669
23670 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23671 PyObject *obj;
23672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23673 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23674 return SWIG_Py_Void();
23675 }
23676
23677 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23678 return SWIG_Python_InitShadowInstance(args);
23679 }
23680
23681 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23682 PyObject *resultobj = 0;
23683 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23684 int arg2 = (int) 0 ;
23685 wxFocusEvent *result = 0 ;
23686 int val1 ;
23687 int ecode1 = 0 ;
23688 int val2 ;
23689 int ecode2 = 0 ;
23690 PyObject * obj0 = 0 ;
23691 PyObject * obj1 = 0 ;
23692 char * kwnames[] = {
23693 (char *) "type",(char *) "winid", NULL
23694 };
23695
23696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23697 if (obj0) {
23698 ecode1 = SWIG_AsVal_int(obj0, &val1);
23699 if (!SWIG_IsOK(ecode1)) {
23700 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23701 }
23702 arg1 = static_cast< wxEventType >(val1);
23703 }
23704 if (obj1) {
23705 ecode2 = SWIG_AsVal_int(obj1, &val2);
23706 if (!SWIG_IsOK(ecode2)) {
23707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23708 }
23709 arg2 = static_cast< int >(val2);
23710 }
23711 {
23712 PyThreadState* __tstate = wxPyBeginAllowThreads();
23713 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23714 wxPyEndAllowThreads(__tstate);
23715 if (PyErr_Occurred()) SWIG_fail;
23716 }
23717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23718 return resultobj;
23719 fail:
23720 return NULL;
23721 }
23722
23723
23724 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23725 PyObject *resultobj = 0;
23726 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23727 wxWindow *result = 0 ;
23728 void *argp1 = 0 ;
23729 int res1 = 0 ;
23730 PyObject *swig_obj[1] ;
23731
23732 if (!args) SWIG_fail;
23733 swig_obj[0] = args;
23734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23735 if (!SWIG_IsOK(res1)) {
23736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23737 }
23738 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23739 {
23740 PyThreadState* __tstate = wxPyBeginAllowThreads();
23741 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23742 wxPyEndAllowThreads(__tstate);
23743 if (PyErr_Occurred()) SWIG_fail;
23744 }
23745 {
23746 resultobj = wxPyMake_wxObject(result, (bool)0);
23747 }
23748 return resultobj;
23749 fail:
23750 return NULL;
23751 }
23752
23753
23754 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23755 PyObject *resultobj = 0;
23756 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23757 wxWindow *arg2 = (wxWindow *) 0 ;
23758 void *argp1 = 0 ;
23759 int res1 = 0 ;
23760 void *argp2 = 0 ;
23761 int res2 = 0 ;
23762 PyObject * obj0 = 0 ;
23763 PyObject * obj1 = 0 ;
23764 char * kwnames[] = {
23765 (char *) "self",(char *) "win", NULL
23766 };
23767
23768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23770 if (!SWIG_IsOK(res1)) {
23771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23772 }
23773 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23774 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23775 if (!SWIG_IsOK(res2)) {
23776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23777 }
23778 arg2 = reinterpret_cast< wxWindow * >(argp2);
23779 {
23780 PyThreadState* __tstate = wxPyBeginAllowThreads();
23781 (arg1)->SetWindow(arg2);
23782 wxPyEndAllowThreads(__tstate);
23783 if (PyErr_Occurred()) SWIG_fail;
23784 }
23785 resultobj = SWIG_Py_Void();
23786 return resultobj;
23787 fail:
23788 return NULL;
23789 }
23790
23791
23792 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23793 PyObject *obj;
23794 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23795 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23796 return SWIG_Py_Void();
23797 }
23798
23799 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23800 return SWIG_Python_InitShadowInstance(args);
23801 }
23802
23803 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23804 PyObject *resultobj = 0;
23805 wxWindow *arg1 = (wxWindow *) NULL ;
23806 wxChildFocusEvent *result = 0 ;
23807 void *argp1 = 0 ;
23808 int res1 = 0 ;
23809 PyObject * obj0 = 0 ;
23810 char * kwnames[] = {
23811 (char *) "win", NULL
23812 };
23813
23814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23815 if (obj0) {
23816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23817 if (!SWIG_IsOK(res1)) {
23818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23819 }
23820 arg1 = reinterpret_cast< wxWindow * >(argp1);
23821 }
23822 {
23823 PyThreadState* __tstate = wxPyBeginAllowThreads();
23824 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23825 wxPyEndAllowThreads(__tstate);
23826 if (PyErr_Occurred()) SWIG_fail;
23827 }
23828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23829 return resultobj;
23830 fail:
23831 return NULL;
23832 }
23833
23834
23835 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23836 PyObject *resultobj = 0;
23837 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23838 wxWindow *result = 0 ;
23839 void *argp1 = 0 ;
23840 int res1 = 0 ;
23841 PyObject *swig_obj[1] ;
23842
23843 if (!args) SWIG_fail;
23844 swig_obj[0] = args;
23845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23846 if (!SWIG_IsOK(res1)) {
23847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23848 }
23849 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23850 {
23851 PyThreadState* __tstate = wxPyBeginAllowThreads();
23852 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23853 wxPyEndAllowThreads(__tstate);
23854 if (PyErr_Occurred()) SWIG_fail;
23855 }
23856 {
23857 resultobj = wxPyMake_wxObject(result, (bool)0);
23858 }
23859 return resultobj;
23860 fail:
23861 return NULL;
23862 }
23863
23864
23865 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23866 PyObject *obj;
23867 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23868 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23869 return SWIG_Py_Void();
23870 }
23871
23872 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23873 return SWIG_Python_InitShadowInstance(args);
23874 }
23875
23876 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23877 PyObject *resultobj = 0;
23878 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23879 bool arg2 = (bool) true ;
23880 int arg3 = (int) 0 ;
23881 wxActivateEvent *result = 0 ;
23882 int val1 ;
23883 int ecode1 = 0 ;
23884 bool val2 ;
23885 int ecode2 = 0 ;
23886 int val3 ;
23887 int ecode3 = 0 ;
23888 PyObject * obj0 = 0 ;
23889 PyObject * obj1 = 0 ;
23890 PyObject * obj2 = 0 ;
23891 char * kwnames[] = {
23892 (char *) "type",(char *) "active",(char *) "Id", NULL
23893 };
23894
23895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23896 if (obj0) {
23897 ecode1 = SWIG_AsVal_int(obj0, &val1);
23898 if (!SWIG_IsOK(ecode1)) {
23899 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23900 }
23901 arg1 = static_cast< wxEventType >(val1);
23902 }
23903 if (obj1) {
23904 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23905 if (!SWIG_IsOK(ecode2)) {
23906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23907 }
23908 arg2 = static_cast< bool >(val2);
23909 }
23910 if (obj2) {
23911 ecode3 = SWIG_AsVal_int(obj2, &val3);
23912 if (!SWIG_IsOK(ecode3)) {
23913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23914 }
23915 arg3 = static_cast< int >(val3);
23916 }
23917 {
23918 PyThreadState* __tstate = wxPyBeginAllowThreads();
23919 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23920 wxPyEndAllowThreads(__tstate);
23921 if (PyErr_Occurred()) SWIG_fail;
23922 }
23923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23924 return resultobj;
23925 fail:
23926 return NULL;
23927 }
23928
23929
23930 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23931 PyObject *resultobj = 0;
23932 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23933 bool result;
23934 void *argp1 = 0 ;
23935 int res1 = 0 ;
23936 PyObject *swig_obj[1] ;
23937
23938 if (!args) SWIG_fail;
23939 swig_obj[0] = args;
23940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23941 if (!SWIG_IsOK(res1)) {
23942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23943 }
23944 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23945 {
23946 PyThreadState* __tstate = wxPyBeginAllowThreads();
23947 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23948 wxPyEndAllowThreads(__tstate);
23949 if (PyErr_Occurred()) SWIG_fail;
23950 }
23951 {
23952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23953 }
23954 return resultobj;
23955 fail:
23956 return NULL;
23957 }
23958
23959
23960 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23961 PyObject *obj;
23962 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23963 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23964 return SWIG_Py_Void();
23965 }
23966
23967 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23968 return SWIG_Python_InitShadowInstance(args);
23969 }
23970
23971 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23972 PyObject *resultobj = 0;
23973 int arg1 = (int) 0 ;
23974 wxInitDialogEvent *result = 0 ;
23975 int val1 ;
23976 int ecode1 = 0 ;
23977 PyObject * obj0 = 0 ;
23978 char * kwnames[] = {
23979 (char *) "Id", NULL
23980 };
23981
23982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23983 if (obj0) {
23984 ecode1 = SWIG_AsVal_int(obj0, &val1);
23985 if (!SWIG_IsOK(ecode1)) {
23986 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23987 }
23988 arg1 = static_cast< int >(val1);
23989 }
23990 {
23991 PyThreadState* __tstate = wxPyBeginAllowThreads();
23992 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23993 wxPyEndAllowThreads(__tstate);
23994 if (PyErr_Occurred()) SWIG_fail;
23995 }
23996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23997 return resultobj;
23998 fail:
23999 return NULL;
24000 }
24001
24002
24003 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24004 PyObject *obj;
24005 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24006 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24007 return SWIG_Py_Void();
24008 }
24009
24010 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24011 return SWIG_Python_InitShadowInstance(args);
24012 }
24013
24014 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24015 PyObject *resultobj = 0;
24016 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24017 int arg2 = (int) 0 ;
24018 wxMenu *arg3 = (wxMenu *) NULL ;
24019 wxMenuEvent *result = 0 ;
24020 int val1 ;
24021 int ecode1 = 0 ;
24022 int val2 ;
24023 int ecode2 = 0 ;
24024 void *argp3 = 0 ;
24025 int res3 = 0 ;
24026 PyObject * obj0 = 0 ;
24027 PyObject * obj1 = 0 ;
24028 PyObject * obj2 = 0 ;
24029 char * kwnames[] = {
24030 (char *) "type",(char *) "winid",(char *) "menu", NULL
24031 };
24032
24033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24034 if (obj0) {
24035 ecode1 = SWIG_AsVal_int(obj0, &val1);
24036 if (!SWIG_IsOK(ecode1)) {
24037 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24038 }
24039 arg1 = static_cast< wxEventType >(val1);
24040 }
24041 if (obj1) {
24042 ecode2 = SWIG_AsVal_int(obj1, &val2);
24043 if (!SWIG_IsOK(ecode2)) {
24044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24045 }
24046 arg2 = static_cast< int >(val2);
24047 }
24048 if (obj2) {
24049 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24050 if (!SWIG_IsOK(res3)) {
24051 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24052 }
24053 arg3 = reinterpret_cast< wxMenu * >(argp3);
24054 }
24055 {
24056 PyThreadState* __tstate = wxPyBeginAllowThreads();
24057 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24058 wxPyEndAllowThreads(__tstate);
24059 if (PyErr_Occurred()) SWIG_fail;
24060 }
24061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24062 return resultobj;
24063 fail:
24064 return NULL;
24065 }
24066
24067
24068 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24069 PyObject *resultobj = 0;
24070 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24071 int result;
24072 void *argp1 = 0 ;
24073 int res1 = 0 ;
24074 PyObject *swig_obj[1] ;
24075
24076 if (!args) SWIG_fail;
24077 swig_obj[0] = args;
24078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24079 if (!SWIG_IsOK(res1)) {
24080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24081 }
24082 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24083 {
24084 PyThreadState* __tstate = wxPyBeginAllowThreads();
24085 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24086 wxPyEndAllowThreads(__tstate);
24087 if (PyErr_Occurred()) SWIG_fail;
24088 }
24089 resultobj = SWIG_From_int(static_cast< int >(result));
24090 return resultobj;
24091 fail:
24092 return NULL;
24093 }
24094
24095
24096 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24097 PyObject *resultobj = 0;
24098 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24099 bool result;
24100 void *argp1 = 0 ;
24101 int res1 = 0 ;
24102 PyObject *swig_obj[1] ;
24103
24104 if (!args) SWIG_fail;
24105 swig_obj[0] = args;
24106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24107 if (!SWIG_IsOK(res1)) {
24108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24109 }
24110 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24111 {
24112 PyThreadState* __tstate = wxPyBeginAllowThreads();
24113 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24114 wxPyEndAllowThreads(__tstate);
24115 if (PyErr_Occurred()) SWIG_fail;
24116 }
24117 {
24118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24119 }
24120 return resultobj;
24121 fail:
24122 return NULL;
24123 }
24124
24125
24126 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24127 PyObject *resultobj = 0;
24128 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24129 wxMenu *result = 0 ;
24130 void *argp1 = 0 ;
24131 int res1 = 0 ;
24132 PyObject *swig_obj[1] ;
24133
24134 if (!args) SWIG_fail;
24135 swig_obj[0] = args;
24136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24137 if (!SWIG_IsOK(res1)) {
24138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24139 }
24140 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24141 {
24142 PyThreadState* __tstate = wxPyBeginAllowThreads();
24143 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24144 wxPyEndAllowThreads(__tstate);
24145 if (PyErr_Occurred()) SWIG_fail;
24146 }
24147 {
24148 resultobj = wxPyMake_wxObject(result, (bool)0);
24149 }
24150 return resultobj;
24151 fail:
24152 return NULL;
24153 }
24154
24155
24156 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24157 PyObject *obj;
24158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24159 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24160 return SWIG_Py_Void();
24161 }
24162
24163 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24164 return SWIG_Python_InitShadowInstance(args);
24165 }
24166
24167 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24168 PyObject *resultobj = 0;
24169 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24170 int arg2 = (int) 0 ;
24171 wxCloseEvent *result = 0 ;
24172 int val1 ;
24173 int ecode1 = 0 ;
24174 int val2 ;
24175 int ecode2 = 0 ;
24176 PyObject * obj0 = 0 ;
24177 PyObject * obj1 = 0 ;
24178 char * kwnames[] = {
24179 (char *) "type",(char *) "winid", NULL
24180 };
24181
24182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24183 if (obj0) {
24184 ecode1 = SWIG_AsVal_int(obj0, &val1);
24185 if (!SWIG_IsOK(ecode1)) {
24186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24187 }
24188 arg1 = static_cast< wxEventType >(val1);
24189 }
24190 if (obj1) {
24191 ecode2 = SWIG_AsVal_int(obj1, &val2);
24192 if (!SWIG_IsOK(ecode2)) {
24193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24194 }
24195 arg2 = static_cast< int >(val2);
24196 }
24197 {
24198 PyThreadState* __tstate = wxPyBeginAllowThreads();
24199 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24200 wxPyEndAllowThreads(__tstate);
24201 if (PyErr_Occurred()) SWIG_fail;
24202 }
24203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24204 return resultobj;
24205 fail:
24206 return NULL;
24207 }
24208
24209
24210 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24211 PyObject *resultobj = 0;
24212 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24213 bool arg2 ;
24214 void *argp1 = 0 ;
24215 int res1 = 0 ;
24216 bool val2 ;
24217 int ecode2 = 0 ;
24218 PyObject * obj0 = 0 ;
24219 PyObject * obj1 = 0 ;
24220 char * kwnames[] = {
24221 (char *) "self",(char *) "logOff", NULL
24222 };
24223
24224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24226 if (!SWIG_IsOK(res1)) {
24227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24228 }
24229 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24230 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24231 if (!SWIG_IsOK(ecode2)) {
24232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24233 }
24234 arg2 = static_cast< bool >(val2);
24235 {
24236 PyThreadState* __tstate = wxPyBeginAllowThreads();
24237 (arg1)->SetLoggingOff(arg2);
24238 wxPyEndAllowThreads(__tstate);
24239 if (PyErr_Occurred()) SWIG_fail;
24240 }
24241 resultobj = SWIG_Py_Void();
24242 return resultobj;
24243 fail:
24244 return NULL;
24245 }
24246
24247
24248 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24249 PyObject *resultobj = 0;
24250 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24251 bool result;
24252 void *argp1 = 0 ;
24253 int res1 = 0 ;
24254 PyObject *swig_obj[1] ;
24255
24256 if (!args) SWIG_fail;
24257 swig_obj[0] = args;
24258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24259 if (!SWIG_IsOK(res1)) {
24260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24261 }
24262 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24263 {
24264 PyThreadState* __tstate = wxPyBeginAllowThreads();
24265 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24266 wxPyEndAllowThreads(__tstate);
24267 if (PyErr_Occurred()) SWIG_fail;
24268 }
24269 {
24270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24271 }
24272 return resultobj;
24273 fail:
24274 return NULL;
24275 }
24276
24277
24278 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24279 PyObject *resultobj = 0;
24280 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24281 bool arg2 = (bool) true ;
24282 void *argp1 = 0 ;
24283 int res1 = 0 ;
24284 bool val2 ;
24285 int ecode2 = 0 ;
24286 PyObject * obj0 = 0 ;
24287 PyObject * obj1 = 0 ;
24288 char * kwnames[] = {
24289 (char *) "self",(char *) "veto", NULL
24290 };
24291
24292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24294 if (!SWIG_IsOK(res1)) {
24295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24296 }
24297 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24298 if (obj1) {
24299 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24300 if (!SWIG_IsOK(ecode2)) {
24301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24302 }
24303 arg2 = static_cast< bool >(val2);
24304 }
24305 {
24306 PyThreadState* __tstate = wxPyBeginAllowThreads();
24307 (arg1)->Veto(arg2);
24308 wxPyEndAllowThreads(__tstate);
24309 if (PyErr_Occurred()) SWIG_fail;
24310 }
24311 resultobj = SWIG_Py_Void();
24312 return resultobj;
24313 fail:
24314 return NULL;
24315 }
24316
24317
24318 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24319 PyObject *resultobj = 0;
24320 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24321 bool result;
24322 void *argp1 = 0 ;
24323 int res1 = 0 ;
24324 PyObject *swig_obj[1] ;
24325
24326 if (!args) SWIG_fail;
24327 swig_obj[0] = args;
24328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24329 if (!SWIG_IsOK(res1)) {
24330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24331 }
24332 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24333 {
24334 PyThreadState* __tstate = wxPyBeginAllowThreads();
24335 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24336 wxPyEndAllowThreads(__tstate);
24337 if (PyErr_Occurred()) SWIG_fail;
24338 }
24339 {
24340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24341 }
24342 return resultobj;
24343 fail:
24344 return NULL;
24345 }
24346
24347
24348 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24349 PyObject *resultobj = 0;
24350 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24351 bool arg2 ;
24352 void *argp1 = 0 ;
24353 int res1 = 0 ;
24354 bool val2 ;
24355 int ecode2 = 0 ;
24356 PyObject * obj0 = 0 ;
24357 PyObject * obj1 = 0 ;
24358 char * kwnames[] = {
24359 (char *) "self",(char *) "canVeto", NULL
24360 };
24361
24362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24364 if (!SWIG_IsOK(res1)) {
24365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24366 }
24367 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24368 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24369 if (!SWIG_IsOK(ecode2)) {
24370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24371 }
24372 arg2 = static_cast< bool >(val2);
24373 {
24374 PyThreadState* __tstate = wxPyBeginAllowThreads();
24375 (arg1)->SetCanVeto(arg2);
24376 wxPyEndAllowThreads(__tstate);
24377 if (PyErr_Occurred()) SWIG_fail;
24378 }
24379 resultobj = SWIG_Py_Void();
24380 return resultobj;
24381 fail:
24382 return NULL;
24383 }
24384
24385
24386 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24387 PyObject *resultobj = 0;
24388 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24389 bool result;
24390 void *argp1 = 0 ;
24391 int res1 = 0 ;
24392 PyObject *swig_obj[1] ;
24393
24394 if (!args) SWIG_fail;
24395 swig_obj[0] = args;
24396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24397 if (!SWIG_IsOK(res1)) {
24398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24399 }
24400 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24401 {
24402 PyThreadState* __tstate = wxPyBeginAllowThreads();
24403 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24404 wxPyEndAllowThreads(__tstate);
24405 if (PyErr_Occurred()) SWIG_fail;
24406 }
24407 {
24408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24409 }
24410 return resultobj;
24411 fail:
24412 return NULL;
24413 }
24414
24415
24416 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24417 PyObject *obj;
24418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24419 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24420 return SWIG_Py_Void();
24421 }
24422
24423 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24424 return SWIG_Python_InitShadowInstance(args);
24425 }
24426
24427 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24428 PyObject *resultobj = 0;
24429 int arg1 = (int) 0 ;
24430 bool arg2 = (bool) false ;
24431 wxShowEvent *result = 0 ;
24432 int val1 ;
24433 int ecode1 = 0 ;
24434 bool val2 ;
24435 int ecode2 = 0 ;
24436 PyObject * obj0 = 0 ;
24437 PyObject * obj1 = 0 ;
24438 char * kwnames[] = {
24439 (char *) "winid",(char *) "show", NULL
24440 };
24441
24442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24443 if (obj0) {
24444 ecode1 = SWIG_AsVal_int(obj0, &val1);
24445 if (!SWIG_IsOK(ecode1)) {
24446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24447 }
24448 arg1 = static_cast< int >(val1);
24449 }
24450 if (obj1) {
24451 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24452 if (!SWIG_IsOK(ecode2)) {
24453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24454 }
24455 arg2 = static_cast< bool >(val2);
24456 }
24457 {
24458 PyThreadState* __tstate = wxPyBeginAllowThreads();
24459 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24460 wxPyEndAllowThreads(__tstate);
24461 if (PyErr_Occurred()) SWIG_fail;
24462 }
24463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24464 return resultobj;
24465 fail:
24466 return NULL;
24467 }
24468
24469
24470 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24471 PyObject *resultobj = 0;
24472 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24473 bool arg2 ;
24474 void *argp1 = 0 ;
24475 int res1 = 0 ;
24476 bool val2 ;
24477 int ecode2 = 0 ;
24478 PyObject * obj0 = 0 ;
24479 PyObject * obj1 = 0 ;
24480 char * kwnames[] = {
24481 (char *) "self",(char *) "show", NULL
24482 };
24483
24484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24486 if (!SWIG_IsOK(res1)) {
24487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24488 }
24489 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24490 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24491 if (!SWIG_IsOK(ecode2)) {
24492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24493 }
24494 arg2 = static_cast< bool >(val2);
24495 {
24496 PyThreadState* __tstate = wxPyBeginAllowThreads();
24497 (arg1)->SetShow(arg2);
24498 wxPyEndAllowThreads(__tstate);
24499 if (PyErr_Occurred()) SWIG_fail;
24500 }
24501 resultobj = SWIG_Py_Void();
24502 return resultobj;
24503 fail:
24504 return NULL;
24505 }
24506
24507
24508 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24509 PyObject *resultobj = 0;
24510 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24511 bool result;
24512 void *argp1 = 0 ;
24513 int res1 = 0 ;
24514 PyObject *swig_obj[1] ;
24515
24516 if (!args) SWIG_fail;
24517 swig_obj[0] = args;
24518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24519 if (!SWIG_IsOK(res1)) {
24520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24521 }
24522 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24523 {
24524 PyThreadState* __tstate = wxPyBeginAllowThreads();
24525 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24526 wxPyEndAllowThreads(__tstate);
24527 if (PyErr_Occurred()) SWIG_fail;
24528 }
24529 {
24530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24531 }
24532 return resultobj;
24533 fail:
24534 return NULL;
24535 }
24536
24537
24538 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24539 PyObject *obj;
24540 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24541 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24542 return SWIG_Py_Void();
24543 }
24544
24545 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24546 return SWIG_Python_InitShadowInstance(args);
24547 }
24548
24549 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24550 PyObject *resultobj = 0;
24551 int arg1 = (int) 0 ;
24552 bool arg2 = (bool) true ;
24553 wxIconizeEvent *result = 0 ;
24554 int val1 ;
24555 int ecode1 = 0 ;
24556 bool val2 ;
24557 int ecode2 = 0 ;
24558 PyObject * obj0 = 0 ;
24559 PyObject * obj1 = 0 ;
24560 char * kwnames[] = {
24561 (char *) "id",(char *) "iconized", NULL
24562 };
24563
24564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24565 if (obj0) {
24566 ecode1 = SWIG_AsVal_int(obj0, &val1);
24567 if (!SWIG_IsOK(ecode1)) {
24568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24569 }
24570 arg1 = static_cast< int >(val1);
24571 }
24572 if (obj1) {
24573 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24574 if (!SWIG_IsOK(ecode2)) {
24575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24576 }
24577 arg2 = static_cast< bool >(val2);
24578 }
24579 {
24580 PyThreadState* __tstate = wxPyBeginAllowThreads();
24581 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24582 wxPyEndAllowThreads(__tstate);
24583 if (PyErr_Occurred()) SWIG_fail;
24584 }
24585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24586 return resultobj;
24587 fail:
24588 return NULL;
24589 }
24590
24591
24592 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24593 PyObject *resultobj = 0;
24594 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24595 bool result;
24596 void *argp1 = 0 ;
24597 int res1 = 0 ;
24598 PyObject *swig_obj[1] ;
24599
24600 if (!args) SWIG_fail;
24601 swig_obj[0] = args;
24602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24603 if (!SWIG_IsOK(res1)) {
24604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24605 }
24606 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24607 {
24608 PyThreadState* __tstate = wxPyBeginAllowThreads();
24609 result = (bool)(arg1)->Iconized();
24610 wxPyEndAllowThreads(__tstate);
24611 if (PyErr_Occurred()) SWIG_fail;
24612 }
24613 {
24614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24615 }
24616 return resultobj;
24617 fail:
24618 return NULL;
24619 }
24620
24621
24622 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24623 PyObject *obj;
24624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24625 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24626 return SWIG_Py_Void();
24627 }
24628
24629 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24630 return SWIG_Python_InitShadowInstance(args);
24631 }
24632
24633 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24634 PyObject *resultobj = 0;
24635 int arg1 = (int) 0 ;
24636 wxMaximizeEvent *result = 0 ;
24637 int val1 ;
24638 int ecode1 = 0 ;
24639 PyObject * obj0 = 0 ;
24640 char * kwnames[] = {
24641 (char *) "id", NULL
24642 };
24643
24644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24645 if (obj0) {
24646 ecode1 = SWIG_AsVal_int(obj0, &val1);
24647 if (!SWIG_IsOK(ecode1)) {
24648 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24649 }
24650 arg1 = static_cast< int >(val1);
24651 }
24652 {
24653 PyThreadState* __tstate = wxPyBeginAllowThreads();
24654 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24655 wxPyEndAllowThreads(__tstate);
24656 if (PyErr_Occurred()) SWIG_fail;
24657 }
24658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24659 return resultobj;
24660 fail:
24661 return NULL;
24662 }
24663
24664
24665 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24666 PyObject *obj;
24667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24668 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24669 return SWIG_Py_Void();
24670 }
24671
24672 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24673 return SWIG_Python_InitShadowInstance(args);
24674 }
24675
24676 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24677 PyObject *resultobj = 0;
24678 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24679 wxPoint result;
24680 void *argp1 = 0 ;
24681 int res1 = 0 ;
24682 PyObject *swig_obj[1] ;
24683
24684 if (!args) SWIG_fail;
24685 swig_obj[0] = args;
24686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24687 if (!SWIG_IsOK(res1)) {
24688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24689 }
24690 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24691 {
24692 PyThreadState* __tstate = wxPyBeginAllowThreads();
24693 result = (arg1)->GetPosition();
24694 wxPyEndAllowThreads(__tstate);
24695 if (PyErr_Occurred()) SWIG_fail;
24696 }
24697 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24698 return resultobj;
24699 fail:
24700 return NULL;
24701 }
24702
24703
24704 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24705 PyObject *resultobj = 0;
24706 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24707 int result;
24708 void *argp1 = 0 ;
24709 int res1 = 0 ;
24710 PyObject *swig_obj[1] ;
24711
24712 if (!args) SWIG_fail;
24713 swig_obj[0] = args;
24714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24715 if (!SWIG_IsOK(res1)) {
24716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24717 }
24718 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24719 {
24720 PyThreadState* __tstate = wxPyBeginAllowThreads();
24721 result = (int)(arg1)->GetNumberOfFiles();
24722 wxPyEndAllowThreads(__tstate);
24723 if (PyErr_Occurred()) SWIG_fail;
24724 }
24725 resultobj = SWIG_From_int(static_cast< int >(result));
24726 return resultobj;
24727 fail:
24728 return NULL;
24729 }
24730
24731
24732 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24733 PyObject *resultobj = 0;
24734 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24735 PyObject *result = 0 ;
24736 void *argp1 = 0 ;
24737 int res1 = 0 ;
24738 PyObject *swig_obj[1] ;
24739
24740 if (!args) SWIG_fail;
24741 swig_obj[0] = args;
24742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24743 if (!SWIG_IsOK(res1)) {
24744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24745 }
24746 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24747 {
24748 PyThreadState* __tstate = wxPyBeginAllowThreads();
24749 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24750 wxPyEndAllowThreads(__tstate);
24751 if (PyErr_Occurred()) SWIG_fail;
24752 }
24753 resultobj = result;
24754 return resultobj;
24755 fail:
24756 return NULL;
24757 }
24758
24759
24760 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24761 PyObject *obj;
24762 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24763 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24764 return SWIG_Py_Void();
24765 }
24766
24767 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24768 PyObject *resultobj = 0;
24769 int arg1 = (int) 0 ;
24770 wxUpdateUIEvent *result = 0 ;
24771 int val1 ;
24772 int ecode1 = 0 ;
24773 PyObject * obj0 = 0 ;
24774 char * kwnames[] = {
24775 (char *) "commandId", NULL
24776 };
24777
24778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24779 if (obj0) {
24780 ecode1 = SWIG_AsVal_int(obj0, &val1);
24781 if (!SWIG_IsOK(ecode1)) {
24782 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24783 }
24784 arg1 = static_cast< int >(val1);
24785 }
24786 {
24787 PyThreadState* __tstate = wxPyBeginAllowThreads();
24788 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24789 wxPyEndAllowThreads(__tstate);
24790 if (PyErr_Occurred()) SWIG_fail;
24791 }
24792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24793 return resultobj;
24794 fail:
24795 return NULL;
24796 }
24797
24798
24799 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24800 PyObject *resultobj = 0;
24801 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24802 bool result;
24803 void *argp1 = 0 ;
24804 int res1 = 0 ;
24805 PyObject *swig_obj[1] ;
24806
24807 if (!args) SWIG_fail;
24808 swig_obj[0] = args;
24809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24810 if (!SWIG_IsOK(res1)) {
24811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24812 }
24813 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24814 {
24815 PyThreadState* __tstate = wxPyBeginAllowThreads();
24816 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24817 wxPyEndAllowThreads(__tstate);
24818 if (PyErr_Occurred()) SWIG_fail;
24819 }
24820 {
24821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24822 }
24823 return resultobj;
24824 fail:
24825 return NULL;
24826 }
24827
24828
24829 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24830 PyObject *resultobj = 0;
24831 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24832 bool result;
24833 void *argp1 = 0 ;
24834 int res1 = 0 ;
24835 PyObject *swig_obj[1] ;
24836
24837 if (!args) SWIG_fail;
24838 swig_obj[0] = args;
24839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24840 if (!SWIG_IsOK(res1)) {
24841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24842 }
24843 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24844 {
24845 PyThreadState* __tstate = wxPyBeginAllowThreads();
24846 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24847 wxPyEndAllowThreads(__tstate);
24848 if (PyErr_Occurred()) SWIG_fail;
24849 }
24850 {
24851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24852 }
24853 return resultobj;
24854 fail:
24855 return NULL;
24856 }
24857
24858
24859 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24860 PyObject *resultobj = 0;
24861 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24862 bool result;
24863 void *argp1 = 0 ;
24864 int res1 = 0 ;
24865 PyObject *swig_obj[1] ;
24866
24867 if (!args) SWIG_fail;
24868 swig_obj[0] = args;
24869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24870 if (!SWIG_IsOK(res1)) {
24871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24872 }
24873 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24874 {
24875 PyThreadState* __tstate = wxPyBeginAllowThreads();
24876 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24877 wxPyEndAllowThreads(__tstate);
24878 if (PyErr_Occurred()) SWIG_fail;
24879 }
24880 {
24881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24882 }
24883 return resultobj;
24884 fail:
24885 return NULL;
24886 }
24887
24888
24889 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24890 PyObject *resultobj = 0;
24891 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24892 wxString result;
24893 void *argp1 = 0 ;
24894 int res1 = 0 ;
24895 PyObject *swig_obj[1] ;
24896
24897 if (!args) SWIG_fail;
24898 swig_obj[0] = args;
24899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24900 if (!SWIG_IsOK(res1)) {
24901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24902 }
24903 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24907 wxPyEndAllowThreads(__tstate);
24908 if (PyErr_Occurred()) SWIG_fail;
24909 }
24910 {
24911 #if wxUSE_UNICODE
24912 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24913 #else
24914 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24915 #endif
24916 }
24917 return resultobj;
24918 fail:
24919 return NULL;
24920 }
24921
24922
24923 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24924 PyObject *resultobj = 0;
24925 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24926 bool result;
24927 void *argp1 = 0 ;
24928 int res1 = 0 ;
24929 PyObject *swig_obj[1] ;
24930
24931 if (!args) SWIG_fail;
24932 swig_obj[0] = args;
24933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24934 if (!SWIG_IsOK(res1)) {
24935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24936 }
24937 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24938 {
24939 PyThreadState* __tstate = wxPyBeginAllowThreads();
24940 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24941 wxPyEndAllowThreads(__tstate);
24942 if (PyErr_Occurred()) SWIG_fail;
24943 }
24944 {
24945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24946 }
24947 return resultobj;
24948 fail:
24949 return NULL;
24950 }
24951
24952
24953 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24954 PyObject *resultobj = 0;
24955 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24956 bool result;
24957 void *argp1 = 0 ;
24958 int res1 = 0 ;
24959 PyObject *swig_obj[1] ;
24960
24961 if (!args) SWIG_fail;
24962 swig_obj[0] = args;
24963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24964 if (!SWIG_IsOK(res1)) {
24965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24966 }
24967 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24968 {
24969 PyThreadState* __tstate = wxPyBeginAllowThreads();
24970 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24971 wxPyEndAllowThreads(__tstate);
24972 if (PyErr_Occurred()) SWIG_fail;
24973 }
24974 {
24975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24976 }
24977 return resultobj;
24978 fail:
24979 return NULL;
24980 }
24981
24982
24983 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24984 PyObject *resultobj = 0;
24985 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24986 bool result;
24987 void *argp1 = 0 ;
24988 int res1 = 0 ;
24989 PyObject *swig_obj[1] ;
24990
24991 if (!args) SWIG_fail;
24992 swig_obj[0] = args;
24993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24994 if (!SWIG_IsOK(res1)) {
24995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24996 }
24997 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24998 {
24999 PyThreadState* __tstate = wxPyBeginAllowThreads();
25000 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25001 wxPyEndAllowThreads(__tstate);
25002 if (PyErr_Occurred()) SWIG_fail;
25003 }
25004 {
25005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25006 }
25007 return resultobj;
25008 fail:
25009 return NULL;
25010 }
25011
25012
25013 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25014 PyObject *resultobj = 0;
25015 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25016 bool result;
25017 void *argp1 = 0 ;
25018 int res1 = 0 ;
25019 PyObject *swig_obj[1] ;
25020
25021 if (!args) SWIG_fail;
25022 swig_obj[0] = args;
25023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25024 if (!SWIG_IsOK(res1)) {
25025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25026 }
25027 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25028 {
25029 PyThreadState* __tstate = wxPyBeginAllowThreads();
25030 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25031 wxPyEndAllowThreads(__tstate);
25032 if (PyErr_Occurred()) SWIG_fail;
25033 }
25034 {
25035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25036 }
25037 return resultobj;
25038 fail:
25039 return NULL;
25040 }
25041
25042
25043 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25044 PyObject *resultobj = 0;
25045 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25046 bool arg2 ;
25047 void *argp1 = 0 ;
25048 int res1 = 0 ;
25049 bool val2 ;
25050 int ecode2 = 0 ;
25051 PyObject * obj0 = 0 ;
25052 PyObject * obj1 = 0 ;
25053 char * kwnames[] = {
25054 (char *) "self",(char *) "check", NULL
25055 };
25056
25057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25059 if (!SWIG_IsOK(res1)) {
25060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25061 }
25062 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25063 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25064 if (!SWIG_IsOK(ecode2)) {
25065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25066 }
25067 arg2 = static_cast< bool >(val2);
25068 {
25069 PyThreadState* __tstate = wxPyBeginAllowThreads();
25070 (arg1)->Check(arg2);
25071 wxPyEndAllowThreads(__tstate);
25072 if (PyErr_Occurred()) SWIG_fail;
25073 }
25074 resultobj = SWIG_Py_Void();
25075 return resultobj;
25076 fail:
25077 return NULL;
25078 }
25079
25080
25081 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25082 PyObject *resultobj = 0;
25083 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25084 bool arg2 ;
25085 void *argp1 = 0 ;
25086 int res1 = 0 ;
25087 bool val2 ;
25088 int ecode2 = 0 ;
25089 PyObject * obj0 = 0 ;
25090 PyObject * obj1 = 0 ;
25091 char * kwnames[] = {
25092 (char *) "self",(char *) "enable", NULL
25093 };
25094
25095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25097 if (!SWIG_IsOK(res1)) {
25098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25099 }
25100 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25101 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25102 if (!SWIG_IsOK(ecode2)) {
25103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25104 }
25105 arg2 = static_cast< bool >(val2);
25106 {
25107 PyThreadState* __tstate = wxPyBeginAllowThreads();
25108 (arg1)->Enable(arg2);
25109 wxPyEndAllowThreads(__tstate);
25110 if (PyErr_Occurred()) SWIG_fail;
25111 }
25112 resultobj = SWIG_Py_Void();
25113 return resultobj;
25114 fail:
25115 return NULL;
25116 }
25117
25118
25119 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25120 PyObject *resultobj = 0;
25121 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25122 bool arg2 ;
25123 void *argp1 = 0 ;
25124 int res1 = 0 ;
25125 bool val2 ;
25126 int ecode2 = 0 ;
25127 PyObject * obj0 = 0 ;
25128 PyObject * obj1 = 0 ;
25129 char * kwnames[] = {
25130 (char *) "self",(char *) "show", NULL
25131 };
25132
25133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25135 if (!SWIG_IsOK(res1)) {
25136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25137 }
25138 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25139 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25140 if (!SWIG_IsOK(ecode2)) {
25141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25142 }
25143 arg2 = static_cast< bool >(val2);
25144 {
25145 PyThreadState* __tstate = wxPyBeginAllowThreads();
25146 (arg1)->Show(arg2);
25147 wxPyEndAllowThreads(__tstate);
25148 if (PyErr_Occurred()) SWIG_fail;
25149 }
25150 resultobj = SWIG_Py_Void();
25151 return resultobj;
25152 fail:
25153 return NULL;
25154 }
25155
25156
25157 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25158 PyObject *resultobj = 0;
25159 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25160 wxString *arg2 = 0 ;
25161 void *argp1 = 0 ;
25162 int res1 = 0 ;
25163 bool temp2 = false ;
25164 PyObject * obj0 = 0 ;
25165 PyObject * obj1 = 0 ;
25166 char * kwnames[] = {
25167 (char *) "self",(char *) "text", NULL
25168 };
25169
25170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25172 if (!SWIG_IsOK(res1)) {
25173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25174 }
25175 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25176 {
25177 arg2 = wxString_in_helper(obj1);
25178 if (arg2 == NULL) SWIG_fail;
25179 temp2 = true;
25180 }
25181 {
25182 PyThreadState* __tstate = wxPyBeginAllowThreads();
25183 (arg1)->SetText((wxString const &)*arg2);
25184 wxPyEndAllowThreads(__tstate);
25185 if (PyErr_Occurred()) SWIG_fail;
25186 }
25187 resultobj = SWIG_Py_Void();
25188 {
25189 if (temp2)
25190 delete arg2;
25191 }
25192 return resultobj;
25193 fail:
25194 {
25195 if (temp2)
25196 delete arg2;
25197 }
25198 return NULL;
25199 }
25200
25201
25202 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25203 PyObject *resultobj = 0;
25204 long arg1 ;
25205 long val1 ;
25206 int ecode1 = 0 ;
25207 PyObject * obj0 = 0 ;
25208 char * kwnames[] = {
25209 (char *) "updateInterval", NULL
25210 };
25211
25212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25213 ecode1 = SWIG_AsVal_long(obj0, &val1);
25214 if (!SWIG_IsOK(ecode1)) {
25215 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25216 }
25217 arg1 = static_cast< long >(val1);
25218 {
25219 PyThreadState* __tstate = wxPyBeginAllowThreads();
25220 wxUpdateUIEvent::SetUpdateInterval(arg1);
25221 wxPyEndAllowThreads(__tstate);
25222 if (PyErr_Occurred()) SWIG_fail;
25223 }
25224 resultobj = SWIG_Py_Void();
25225 return resultobj;
25226 fail:
25227 return NULL;
25228 }
25229
25230
25231 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25232 PyObject *resultobj = 0;
25233 long result;
25234
25235 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25236 {
25237 PyThreadState* __tstate = wxPyBeginAllowThreads();
25238 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25239 wxPyEndAllowThreads(__tstate);
25240 if (PyErr_Occurred()) SWIG_fail;
25241 }
25242 resultobj = SWIG_From_long(static_cast< long >(result));
25243 return resultobj;
25244 fail:
25245 return NULL;
25246 }
25247
25248
25249 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25250 PyObject *resultobj = 0;
25251 wxWindow *arg1 = (wxWindow *) 0 ;
25252 bool result;
25253 void *argp1 = 0 ;
25254 int res1 = 0 ;
25255 PyObject * obj0 = 0 ;
25256 char * kwnames[] = {
25257 (char *) "win", NULL
25258 };
25259
25260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25262 if (!SWIG_IsOK(res1)) {
25263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25264 }
25265 arg1 = reinterpret_cast< wxWindow * >(argp1);
25266 {
25267 PyThreadState* __tstate = wxPyBeginAllowThreads();
25268 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25269 wxPyEndAllowThreads(__tstate);
25270 if (PyErr_Occurred()) SWIG_fail;
25271 }
25272 {
25273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25274 }
25275 return resultobj;
25276 fail:
25277 return NULL;
25278 }
25279
25280
25281 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25282 PyObject *resultobj = 0;
25283
25284 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25285 {
25286 PyThreadState* __tstate = wxPyBeginAllowThreads();
25287 wxUpdateUIEvent::ResetUpdateTime();
25288 wxPyEndAllowThreads(__tstate);
25289 if (PyErr_Occurred()) SWIG_fail;
25290 }
25291 resultobj = SWIG_Py_Void();
25292 return resultobj;
25293 fail:
25294 return NULL;
25295 }
25296
25297
25298 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25299 PyObject *resultobj = 0;
25300 wxUpdateUIMode arg1 ;
25301 int val1 ;
25302 int ecode1 = 0 ;
25303 PyObject * obj0 = 0 ;
25304 char * kwnames[] = {
25305 (char *) "mode", NULL
25306 };
25307
25308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25309 ecode1 = SWIG_AsVal_int(obj0, &val1);
25310 if (!SWIG_IsOK(ecode1)) {
25311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25312 }
25313 arg1 = static_cast< wxUpdateUIMode >(val1);
25314 {
25315 PyThreadState* __tstate = wxPyBeginAllowThreads();
25316 wxUpdateUIEvent::SetMode(arg1);
25317 wxPyEndAllowThreads(__tstate);
25318 if (PyErr_Occurred()) SWIG_fail;
25319 }
25320 resultobj = SWIG_Py_Void();
25321 return resultobj;
25322 fail:
25323 return NULL;
25324 }
25325
25326
25327 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25328 PyObject *resultobj = 0;
25329 wxUpdateUIMode result;
25330
25331 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25332 {
25333 PyThreadState* __tstate = wxPyBeginAllowThreads();
25334 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25335 wxPyEndAllowThreads(__tstate);
25336 if (PyErr_Occurred()) SWIG_fail;
25337 }
25338 resultobj = SWIG_From_int(static_cast< int >(result));
25339 return resultobj;
25340 fail:
25341 return NULL;
25342 }
25343
25344
25345 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25346 PyObject *obj;
25347 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25348 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25349 return SWIG_Py_Void();
25350 }
25351
25352 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25353 return SWIG_Python_InitShadowInstance(args);
25354 }
25355
25356 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25357 PyObject *resultobj = 0;
25358 wxSysColourChangedEvent *result = 0 ;
25359
25360 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25361 {
25362 PyThreadState* __tstate = wxPyBeginAllowThreads();
25363 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25364 wxPyEndAllowThreads(__tstate);
25365 if (PyErr_Occurred()) SWIG_fail;
25366 }
25367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25368 return resultobj;
25369 fail:
25370 return NULL;
25371 }
25372
25373
25374 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25375 PyObject *obj;
25376 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25377 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25378 return SWIG_Py_Void();
25379 }
25380
25381 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25382 return SWIG_Python_InitShadowInstance(args);
25383 }
25384
25385 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25386 PyObject *resultobj = 0;
25387 int arg1 = (int) 0 ;
25388 wxWindow *arg2 = (wxWindow *) NULL ;
25389 wxMouseCaptureChangedEvent *result = 0 ;
25390 int val1 ;
25391 int ecode1 = 0 ;
25392 void *argp2 = 0 ;
25393 int res2 = 0 ;
25394 PyObject * obj0 = 0 ;
25395 PyObject * obj1 = 0 ;
25396 char * kwnames[] = {
25397 (char *) "winid",(char *) "gainedCapture", NULL
25398 };
25399
25400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25401 if (obj0) {
25402 ecode1 = SWIG_AsVal_int(obj0, &val1);
25403 if (!SWIG_IsOK(ecode1)) {
25404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25405 }
25406 arg1 = static_cast< int >(val1);
25407 }
25408 if (obj1) {
25409 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25410 if (!SWIG_IsOK(res2)) {
25411 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25412 }
25413 arg2 = reinterpret_cast< wxWindow * >(argp2);
25414 }
25415 {
25416 PyThreadState* __tstate = wxPyBeginAllowThreads();
25417 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25418 wxPyEndAllowThreads(__tstate);
25419 if (PyErr_Occurred()) SWIG_fail;
25420 }
25421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25422 return resultobj;
25423 fail:
25424 return NULL;
25425 }
25426
25427
25428 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25429 PyObject *resultobj = 0;
25430 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25431 wxWindow *result = 0 ;
25432 void *argp1 = 0 ;
25433 int res1 = 0 ;
25434 PyObject *swig_obj[1] ;
25435
25436 if (!args) SWIG_fail;
25437 swig_obj[0] = args;
25438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25439 if (!SWIG_IsOK(res1)) {
25440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25441 }
25442 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25443 {
25444 PyThreadState* __tstate = wxPyBeginAllowThreads();
25445 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25446 wxPyEndAllowThreads(__tstate);
25447 if (PyErr_Occurred()) SWIG_fail;
25448 }
25449 {
25450 resultobj = wxPyMake_wxObject(result, (bool)0);
25451 }
25452 return resultobj;
25453 fail:
25454 return NULL;
25455 }
25456
25457
25458 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25459 PyObject *obj;
25460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25461 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25462 return SWIG_Py_Void();
25463 }
25464
25465 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25466 return SWIG_Python_InitShadowInstance(args);
25467 }
25468
25469 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25470 PyObject *resultobj = 0;
25471 wxDisplayChangedEvent *result = 0 ;
25472
25473 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25474 {
25475 PyThreadState* __tstate = wxPyBeginAllowThreads();
25476 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25477 wxPyEndAllowThreads(__tstate);
25478 if (PyErr_Occurred()) SWIG_fail;
25479 }
25480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25481 return resultobj;
25482 fail:
25483 return NULL;
25484 }
25485
25486
25487 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25488 PyObject *obj;
25489 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25490 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25491 return SWIG_Py_Void();
25492 }
25493
25494 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25495 return SWIG_Python_InitShadowInstance(args);
25496 }
25497
25498 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25499 PyObject *resultobj = 0;
25500 int arg1 = (int) 0 ;
25501 wxPaletteChangedEvent *result = 0 ;
25502 int val1 ;
25503 int ecode1 = 0 ;
25504 PyObject * obj0 = 0 ;
25505 char * kwnames[] = {
25506 (char *) "id", NULL
25507 };
25508
25509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25510 if (obj0) {
25511 ecode1 = SWIG_AsVal_int(obj0, &val1);
25512 if (!SWIG_IsOK(ecode1)) {
25513 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25514 }
25515 arg1 = static_cast< int >(val1);
25516 }
25517 {
25518 PyThreadState* __tstate = wxPyBeginAllowThreads();
25519 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25520 wxPyEndAllowThreads(__tstate);
25521 if (PyErr_Occurred()) SWIG_fail;
25522 }
25523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25524 return resultobj;
25525 fail:
25526 return NULL;
25527 }
25528
25529
25530 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25531 PyObject *resultobj = 0;
25532 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25533 wxWindow *arg2 = (wxWindow *) 0 ;
25534 void *argp1 = 0 ;
25535 int res1 = 0 ;
25536 void *argp2 = 0 ;
25537 int res2 = 0 ;
25538 PyObject * obj0 = 0 ;
25539 PyObject * obj1 = 0 ;
25540 char * kwnames[] = {
25541 (char *) "self",(char *) "win", NULL
25542 };
25543
25544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25546 if (!SWIG_IsOK(res1)) {
25547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25548 }
25549 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25550 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25551 if (!SWIG_IsOK(res2)) {
25552 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25553 }
25554 arg2 = reinterpret_cast< wxWindow * >(argp2);
25555 {
25556 PyThreadState* __tstate = wxPyBeginAllowThreads();
25557 (arg1)->SetChangedWindow(arg2);
25558 wxPyEndAllowThreads(__tstate);
25559 if (PyErr_Occurred()) SWIG_fail;
25560 }
25561 resultobj = SWIG_Py_Void();
25562 return resultobj;
25563 fail:
25564 return NULL;
25565 }
25566
25567
25568 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25569 PyObject *resultobj = 0;
25570 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25571 wxWindow *result = 0 ;
25572 void *argp1 = 0 ;
25573 int res1 = 0 ;
25574 PyObject *swig_obj[1] ;
25575
25576 if (!args) SWIG_fail;
25577 swig_obj[0] = args;
25578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25579 if (!SWIG_IsOK(res1)) {
25580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25581 }
25582 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25583 {
25584 PyThreadState* __tstate = wxPyBeginAllowThreads();
25585 result = (wxWindow *)(arg1)->GetChangedWindow();
25586 wxPyEndAllowThreads(__tstate);
25587 if (PyErr_Occurred()) SWIG_fail;
25588 }
25589 {
25590 resultobj = wxPyMake_wxObject(result, (bool)0);
25591 }
25592 return resultobj;
25593 fail:
25594 return NULL;
25595 }
25596
25597
25598 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25599 PyObject *obj;
25600 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25601 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25602 return SWIG_Py_Void();
25603 }
25604
25605 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25606 return SWIG_Python_InitShadowInstance(args);
25607 }
25608
25609 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25610 PyObject *resultobj = 0;
25611 int arg1 = (int) 0 ;
25612 wxQueryNewPaletteEvent *result = 0 ;
25613 int val1 ;
25614 int ecode1 = 0 ;
25615 PyObject * obj0 = 0 ;
25616 char * kwnames[] = {
25617 (char *) "winid", NULL
25618 };
25619
25620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25621 if (obj0) {
25622 ecode1 = SWIG_AsVal_int(obj0, &val1);
25623 if (!SWIG_IsOK(ecode1)) {
25624 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25625 }
25626 arg1 = static_cast< int >(val1);
25627 }
25628 {
25629 PyThreadState* __tstate = wxPyBeginAllowThreads();
25630 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25631 wxPyEndAllowThreads(__tstate);
25632 if (PyErr_Occurred()) SWIG_fail;
25633 }
25634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25635 return resultobj;
25636 fail:
25637 return NULL;
25638 }
25639
25640
25641 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25642 PyObject *resultobj = 0;
25643 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25644 bool arg2 ;
25645 void *argp1 = 0 ;
25646 int res1 = 0 ;
25647 bool val2 ;
25648 int ecode2 = 0 ;
25649 PyObject * obj0 = 0 ;
25650 PyObject * obj1 = 0 ;
25651 char * kwnames[] = {
25652 (char *) "self",(char *) "realized", NULL
25653 };
25654
25655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25657 if (!SWIG_IsOK(res1)) {
25658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25659 }
25660 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25661 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25662 if (!SWIG_IsOK(ecode2)) {
25663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25664 }
25665 arg2 = static_cast< bool >(val2);
25666 {
25667 PyThreadState* __tstate = wxPyBeginAllowThreads();
25668 (arg1)->SetPaletteRealized(arg2);
25669 wxPyEndAllowThreads(__tstate);
25670 if (PyErr_Occurred()) SWIG_fail;
25671 }
25672 resultobj = SWIG_Py_Void();
25673 return resultobj;
25674 fail:
25675 return NULL;
25676 }
25677
25678
25679 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25680 PyObject *resultobj = 0;
25681 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25682 bool result;
25683 void *argp1 = 0 ;
25684 int res1 = 0 ;
25685 PyObject *swig_obj[1] ;
25686
25687 if (!args) SWIG_fail;
25688 swig_obj[0] = args;
25689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25690 if (!SWIG_IsOK(res1)) {
25691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25692 }
25693 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25694 {
25695 PyThreadState* __tstate = wxPyBeginAllowThreads();
25696 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25697 wxPyEndAllowThreads(__tstate);
25698 if (PyErr_Occurred()) SWIG_fail;
25699 }
25700 {
25701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25702 }
25703 return resultobj;
25704 fail:
25705 return NULL;
25706 }
25707
25708
25709 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25710 PyObject *obj;
25711 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25712 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25713 return SWIG_Py_Void();
25714 }
25715
25716 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25717 return SWIG_Python_InitShadowInstance(args);
25718 }
25719
25720 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25721 PyObject *resultobj = 0;
25722 wxNavigationKeyEvent *result = 0 ;
25723
25724 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25725 {
25726 PyThreadState* __tstate = wxPyBeginAllowThreads();
25727 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25728 wxPyEndAllowThreads(__tstate);
25729 if (PyErr_Occurred()) SWIG_fail;
25730 }
25731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25732 return resultobj;
25733 fail:
25734 return NULL;
25735 }
25736
25737
25738 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25739 PyObject *resultobj = 0;
25740 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25741 bool result;
25742 void *argp1 = 0 ;
25743 int res1 = 0 ;
25744 PyObject *swig_obj[1] ;
25745
25746 if (!args) SWIG_fail;
25747 swig_obj[0] = args;
25748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25749 if (!SWIG_IsOK(res1)) {
25750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25751 }
25752 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25753 {
25754 PyThreadState* __tstate = wxPyBeginAllowThreads();
25755 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25756 wxPyEndAllowThreads(__tstate);
25757 if (PyErr_Occurred()) SWIG_fail;
25758 }
25759 {
25760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25761 }
25762 return resultobj;
25763 fail:
25764 return NULL;
25765 }
25766
25767
25768 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25769 PyObject *resultobj = 0;
25770 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25771 bool arg2 ;
25772 void *argp1 = 0 ;
25773 int res1 = 0 ;
25774 bool val2 ;
25775 int ecode2 = 0 ;
25776 PyObject * obj0 = 0 ;
25777 PyObject * obj1 = 0 ;
25778 char * kwnames[] = {
25779 (char *) "self",(char *) "forward", NULL
25780 };
25781
25782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25784 if (!SWIG_IsOK(res1)) {
25785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25786 }
25787 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25788 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25789 if (!SWIG_IsOK(ecode2)) {
25790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25791 }
25792 arg2 = static_cast< bool >(val2);
25793 {
25794 PyThreadState* __tstate = wxPyBeginAllowThreads();
25795 (arg1)->SetDirection(arg2);
25796 wxPyEndAllowThreads(__tstate);
25797 if (PyErr_Occurred()) SWIG_fail;
25798 }
25799 resultobj = SWIG_Py_Void();
25800 return resultobj;
25801 fail:
25802 return NULL;
25803 }
25804
25805
25806 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25807 PyObject *resultobj = 0;
25808 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25809 bool result;
25810 void *argp1 = 0 ;
25811 int res1 = 0 ;
25812 PyObject *swig_obj[1] ;
25813
25814 if (!args) SWIG_fail;
25815 swig_obj[0] = args;
25816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25817 if (!SWIG_IsOK(res1)) {
25818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25819 }
25820 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25821 {
25822 PyThreadState* __tstate = wxPyBeginAllowThreads();
25823 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25824 wxPyEndAllowThreads(__tstate);
25825 if (PyErr_Occurred()) SWIG_fail;
25826 }
25827 {
25828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25829 }
25830 return resultobj;
25831 fail:
25832 return NULL;
25833 }
25834
25835
25836 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25837 PyObject *resultobj = 0;
25838 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25839 bool arg2 ;
25840 void *argp1 = 0 ;
25841 int res1 = 0 ;
25842 bool val2 ;
25843 int ecode2 = 0 ;
25844 PyObject * obj0 = 0 ;
25845 PyObject * obj1 = 0 ;
25846 char * kwnames[] = {
25847 (char *) "self",(char *) "ischange", NULL
25848 };
25849
25850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25852 if (!SWIG_IsOK(res1)) {
25853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25854 }
25855 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25856 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25857 if (!SWIG_IsOK(ecode2)) {
25858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25859 }
25860 arg2 = static_cast< bool >(val2);
25861 {
25862 PyThreadState* __tstate = wxPyBeginAllowThreads();
25863 (arg1)->SetWindowChange(arg2);
25864 wxPyEndAllowThreads(__tstate);
25865 if (PyErr_Occurred()) SWIG_fail;
25866 }
25867 resultobj = SWIG_Py_Void();
25868 return resultobj;
25869 fail:
25870 return NULL;
25871 }
25872
25873
25874 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25875 PyObject *resultobj = 0;
25876 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25877 bool result;
25878 void *argp1 = 0 ;
25879 int res1 = 0 ;
25880 PyObject *swig_obj[1] ;
25881
25882 if (!args) SWIG_fail;
25883 swig_obj[0] = args;
25884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25885 if (!SWIG_IsOK(res1)) {
25886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25887 }
25888 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25889 {
25890 PyThreadState* __tstate = wxPyBeginAllowThreads();
25891 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25892 wxPyEndAllowThreads(__tstate);
25893 if (PyErr_Occurred()) SWIG_fail;
25894 }
25895 {
25896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25897 }
25898 return resultobj;
25899 fail:
25900 return NULL;
25901 }
25902
25903
25904 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25905 PyObject *resultobj = 0;
25906 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25907 bool arg2 ;
25908 void *argp1 = 0 ;
25909 int res1 = 0 ;
25910 bool val2 ;
25911 int ecode2 = 0 ;
25912 PyObject * obj0 = 0 ;
25913 PyObject * obj1 = 0 ;
25914 char * kwnames[] = {
25915 (char *) "self",(char *) "bIs", NULL
25916 };
25917
25918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25920 if (!SWIG_IsOK(res1)) {
25921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25922 }
25923 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25924 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25925 if (!SWIG_IsOK(ecode2)) {
25926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25927 }
25928 arg2 = static_cast< bool >(val2);
25929 {
25930 PyThreadState* __tstate = wxPyBeginAllowThreads();
25931 (arg1)->SetFromTab(arg2);
25932 wxPyEndAllowThreads(__tstate);
25933 if (PyErr_Occurred()) SWIG_fail;
25934 }
25935 resultobj = SWIG_Py_Void();
25936 return resultobj;
25937 fail:
25938 return NULL;
25939 }
25940
25941
25942 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25943 PyObject *resultobj = 0;
25944 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25945 long arg2 ;
25946 void *argp1 = 0 ;
25947 int res1 = 0 ;
25948 long val2 ;
25949 int ecode2 = 0 ;
25950 PyObject * obj0 = 0 ;
25951 PyObject * obj1 = 0 ;
25952 char * kwnames[] = {
25953 (char *) "self",(char *) "flags", NULL
25954 };
25955
25956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25958 if (!SWIG_IsOK(res1)) {
25959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25960 }
25961 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25962 ecode2 = SWIG_AsVal_long(obj1, &val2);
25963 if (!SWIG_IsOK(ecode2)) {
25964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25965 }
25966 arg2 = static_cast< long >(val2);
25967 {
25968 PyThreadState* __tstate = wxPyBeginAllowThreads();
25969 (arg1)->SetFlags(arg2);
25970 wxPyEndAllowThreads(__tstate);
25971 if (PyErr_Occurred()) SWIG_fail;
25972 }
25973 resultobj = SWIG_Py_Void();
25974 return resultobj;
25975 fail:
25976 return NULL;
25977 }
25978
25979
25980 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25981 PyObject *resultobj = 0;
25982 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25983 wxWindow *result = 0 ;
25984 void *argp1 = 0 ;
25985 int res1 = 0 ;
25986 PyObject *swig_obj[1] ;
25987
25988 if (!args) SWIG_fail;
25989 swig_obj[0] = args;
25990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25991 if (!SWIG_IsOK(res1)) {
25992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25993 }
25994 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25995 {
25996 PyThreadState* __tstate = wxPyBeginAllowThreads();
25997 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25998 wxPyEndAllowThreads(__tstate);
25999 if (PyErr_Occurred()) SWIG_fail;
26000 }
26001 {
26002 resultobj = wxPyMake_wxObject(result, (bool)0);
26003 }
26004 return resultobj;
26005 fail:
26006 return NULL;
26007 }
26008
26009
26010 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26011 PyObject *resultobj = 0;
26012 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26013 wxWindow *arg2 = (wxWindow *) 0 ;
26014 void *argp1 = 0 ;
26015 int res1 = 0 ;
26016 void *argp2 = 0 ;
26017 int res2 = 0 ;
26018 PyObject * obj0 = 0 ;
26019 PyObject * obj1 = 0 ;
26020 char * kwnames[] = {
26021 (char *) "self",(char *) "win", NULL
26022 };
26023
26024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26026 if (!SWIG_IsOK(res1)) {
26027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26028 }
26029 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26030 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26031 if (!SWIG_IsOK(res2)) {
26032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26033 }
26034 arg2 = reinterpret_cast< wxWindow * >(argp2);
26035 {
26036 PyThreadState* __tstate = wxPyBeginAllowThreads();
26037 (arg1)->SetCurrentFocus(arg2);
26038 wxPyEndAllowThreads(__tstate);
26039 if (PyErr_Occurred()) SWIG_fail;
26040 }
26041 resultobj = SWIG_Py_Void();
26042 return resultobj;
26043 fail:
26044 return NULL;
26045 }
26046
26047
26048 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26049 PyObject *obj;
26050 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26051 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26052 return SWIG_Py_Void();
26053 }
26054
26055 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26056 return SWIG_Python_InitShadowInstance(args);
26057 }
26058
26059 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26060 PyObject *resultobj = 0;
26061 wxWindow *arg1 = (wxWindow *) NULL ;
26062 wxWindowCreateEvent *result = 0 ;
26063 void *argp1 = 0 ;
26064 int res1 = 0 ;
26065 PyObject * obj0 = 0 ;
26066 char * kwnames[] = {
26067 (char *) "win", NULL
26068 };
26069
26070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26071 if (obj0) {
26072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26073 if (!SWIG_IsOK(res1)) {
26074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26075 }
26076 arg1 = reinterpret_cast< wxWindow * >(argp1);
26077 }
26078 {
26079 PyThreadState* __tstate = wxPyBeginAllowThreads();
26080 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26081 wxPyEndAllowThreads(__tstate);
26082 if (PyErr_Occurred()) SWIG_fail;
26083 }
26084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26085 return resultobj;
26086 fail:
26087 return NULL;
26088 }
26089
26090
26091 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26092 PyObject *resultobj = 0;
26093 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26094 wxWindow *result = 0 ;
26095 void *argp1 = 0 ;
26096 int res1 = 0 ;
26097 PyObject *swig_obj[1] ;
26098
26099 if (!args) SWIG_fail;
26100 swig_obj[0] = args;
26101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26102 if (!SWIG_IsOK(res1)) {
26103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26104 }
26105 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26106 {
26107 PyThreadState* __tstate = wxPyBeginAllowThreads();
26108 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26109 wxPyEndAllowThreads(__tstate);
26110 if (PyErr_Occurred()) SWIG_fail;
26111 }
26112 {
26113 resultobj = wxPyMake_wxObject(result, (bool)0);
26114 }
26115 return resultobj;
26116 fail:
26117 return NULL;
26118 }
26119
26120
26121 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26122 PyObject *obj;
26123 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26124 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26125 return SWIG_Py_Void();
26126 }
26127
26128 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26129 return SWIG_Python_InitShadowInstance(args);
26130 }
26131
26132 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26133 PyObject *resultobj = 0;
26134 wxWindow *arg1 = (wxWindow *) NULL ;
26135 wxWindowDestroyEvent *result = 0 ;
26136 void *argp1 = 0 ;
26137 int res1 = 0 ;
26138 PyObject * obj0 = 0 ;
26139 char * kwnames[] = {
26140 (char *) "win", NULL
26141 };
26142
26143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26144 if (obj0) {
26145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26146 if (!SWIG_IsOK(res1)) {
26147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26148 }
26149 arg1 = reinterpret_cast< wxWindow * >(argp1);
26150 }
26151 {
26152 PyThreadState* __tstate = wxPyBeginAllowThreads();
26153 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26154 wxPyEndAllowThreads(__tstate);
26155 if (PyErr_Occurred()) SWIG_fail;
26156 }
26157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26158 return resultobj;
26159 fail:
26160 return NULL;
26161 }
26162
26163
26164 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26165 PyObject *resultobj = 0;
26166 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26167 wxWindow *result = 0 ;
26168 void *argp1 = 0 ;
26169 int res1 = 0 ;
26170 PyObject *swig_obj[1] ;
26171
26172 if (!args) SWIG_fail;
26173 swig_obj[0] = args;
26174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26175 if (!SWIG_IsOK(res1)) {
26176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26177 }
26178 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26179 {
26180 PyThreadState* __tstate = wxPyBeginAllowThreads();
26181 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26182 wxPyEndAllowThreads(__tstate);
26183 if (PyErr_Occurred()) SWIG_fail;
26184 }
26185 {
26186 resultobj = wxPyMake_wxObject(result, (bool)0);
26187 }
26188 return resultobj;
26189 fail:
26190 return NULL;
26191 }
26192
26193
26194 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26195 PyObject *obj;
26196 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26197 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26198 return SWIG_Py_Void();
26199 }
26200
26201 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26202 return SWIG_Python_InitShadowInstance(args);
26203 }
26204
26205 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26206 PyObject *resultobj = 0;
26207 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26208 int arg2 = (int) 0 ;
26209 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26210 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26211 wxContextMenuEvent *result = 0 ;
26212 int val1 ;
26213 int ecode1 = 0 ;
26214 int val2 ;
26215 int ecode2 = 0 ;
26216 wxPoint temp3 ;
26217 PyObject * obj0 = 0 ;
26218 PyObject * obj1 = 0 ;
26219 PyObject * obj2 = 0 ;
26220 char * kwnames[] = {
26221 (char *) "type",(char *) "winid",(char *) "pt", NULL
26222 };
26223
26224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26225 if (obj0) {
26226 ecode1 = SWIG_AsVal_int(obj0, &val1);
26227 if (!SWIG_IsOK(ecode1)) {
26228 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26229 }
26230 arg1 = static_cast< wxEventType >(val1);
26231 }
26232 if (obj1) {
26233 ecode2 = SWIG_AsVal_int(obj1, &val2);
26234 if (!SWIG_IsOK(ecode2)) {
26235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26236 }
26237 arg2 = static_cast< int >(val2);
26238 }
26239 if (obj2) {
26240 {
26241 arg3 = &temp3;
26242 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26243 }
26244 }
26245 {
26246 PyThreadState* __tstate = wxPyBeginAllowThreads();
26247 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26248 wxPyEndAllowThreads(__tstate);
26249 if (PyErr_Occurred()) SWIG_fail;
26250 }
26251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26252 return resultobj;
26253 fail:
26254 return NULL;
26255 }
26256
26257
26258 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26259 PyObject *resultobj = 0;
26260 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26261 wxPoint *result = 0 ;
26262 void *argp1 = 0 ;
26263 int res1 = 0 ;
26264 PyObject *swig_obj[1] ;
26265
26266 if (!args) SWIG_fail;
26267 swig_obj[0] = args;
26268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26269 if (!SWIG_IsOK(res1)) {
26270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26271 }
26272 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26273 {
26274 PyThreadState* __tstate = wxPyBeginAllowThreads();
26275 {
26276 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26277 result = (wxPoint *) &_result_ref;
26278 }
26279 wxPyEndAllowThreads(__tstate);
26280 if (PyErr_Occurred()) SWIG_fail;
26281 }
26282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26283 return resultobj;
26284 fail:
26285 return NULL;
26286 }
26287
26288
26289 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26290 PyObject *resultobj = 0;
26291 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26292 wxPoint *arg2 = 0 ;
26293 void *argp1 = 0 ;
26294 int res1 = 0 ;
26295 wxPoint temp2 ;
26296 PyObject * obj0 = 0 ;
26297 PyObject * obj1 = 0 ;
26298 char * kwnames[] = {
26299 (char *) "self",(char *) "pos", NULL
26300 };
26301
26302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26304 if (!SWIG_IsOK(res1)) {
26305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26306 }
26307 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26308 {
26309 arg2 = &temp2;
26310 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26311 }
26312 {
26313 PyThreadState* __tstate = wxPyBeginAllowThreads();
26314 (arg1)->SetPosition((wxPoint const &)*arg2);
26315 wxPyEndAllowThreads(__tstate);
26316 if (PyErr_Occurred()) SWIG_fail;
26317 }
26318 resultobj = SWIG_Py_Void();
26319 return resultobj;
26320 fail:
26321 return NULL;
26322 }
26323
26324
26325 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26326 PyObject *obj;
26327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26328 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26329 return SWIG_Py_Void();
26330 }
26331
26332 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26333 return SWIG_Python_InitShadowInstance(args);
26334 }
26335
26336 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26337 PyObject *resultobj = 0;
26338 wxIdleEvent *result = 0 ;
26339
26340 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26341 {
26342 PyThreadState* __tstate = wxPyBeginAllowThreads();
26343 result = (wxIdleEvent *)new wxIdleEvent();
26344 wxPyEndAllowThreads(__tstate);
26345 if (PyErr_Occurred()) SWIG_fail;
26346 }
26347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26348 return resultobj;
26349 fail:
26350 return NULL;
26351 }
26352
26353
26354 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26355 PyObject *resultobj = 0;
26356 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26357 bool arg2 = (bool) true ;
26358 void *argp1 = 0 ;
26359 int res1 = 0 ;
26360 bool val2 ;
26361 int ecode2 = 0 ;
26362 PyObject * obj0 = 0 ;
26363 PyObject * obj1 = 0 ;
26364 char * kwnames[] = {
26365 (char *) "self",(char *) "needMore", NULL
26366 };
26367
26368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26370 if (!SWIG_IsOK(res1)) {
26371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26372 }
26373 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26374 if (obj1) {
26375 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26376 if (!SWIG_IsOK(ecode2)) {
26377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26378 }
26379 arg2 = static_cast< bool >(val2);
26380 }
26381 {
26382 PyThreadState* __tstate = wxPyBeginAllowThreads();
26383 (arg1)->RequestMore(arg2);
26384 wxPyEndAllowThreads(__tstate);
26385 if (PyErr_Occurred()) SWIG_fail;
26386 }
26387 resultobj = SWIG_Py_Void();
26388 return resultobj;
26389 fail:
26390 return NULL;
26391 }
26392
26393
26394 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26395 PyObject *resultobj = 0;
26396 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26397 bool result;
26398 void *argp1 = 0 ;
26399 int res1 = 0 ;
26400 PyObject *swig_obj[1] ;
26401
26402 if (!args) SWIG_fail;
26403 swig_obj[0] = args;
26404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26405 if (!SWIG_IsOK(res1)) {
26406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26407 }
26408 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26409 {
26410 PyThreadState* __tstate = wxPyBeginAllowThreads();
26411 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26412 wxPyEndAllowThreads(__tstate);
26413 if (PyErr_Occurred()) SWIG_fail;
26414 }
26415 {
26416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26417 }
26418 return resultobj;
26419 fail:
26420 return NULL;
26421 }
26422
26423
26424 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26425 PyObject *resultobj = 0;
26426 wxIdleMode arg1 ;
26427 int val1 ;
26428 int ecode1 = 0 ;
26429 PyObject * obj0 = 0 ;
26430 char * kwnames[] = {
26431 (char *) "mode", NULL
26432 };
26433
26434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26435 ecode1 = SWIG_AsVal_int(obj0, &val1);
26436 if (!SWIG_IsOK(ecode1)) {
26437 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26438 }
26439 arg1 = static_cast< wxIdleMode >(val1);
26440 {
26441 PyThreadState* __tstate = wxPyBeginAllowThreads();
26442 wxIdleEvent::SetMode(arg1);
26443 wxPyEndAllowThreads(__tstate);
26444 if (PyErr_Occurred()) SWIG_fail;
26445 }
26446 resultobj = SWIG_Py_Void();
26447 return resultobj;
26448 fail:
26449 return NULL;
26450 }
26451
26452
26453 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26454 PyObject *resultobj = 0;
26455 wxIdleMode result;
26456
26457 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26458 {
26459 PyThreadState* __tstate = wxPyBeginAllowThreads();
26460 result = (wxIdleMode)wxIdleEvent::GetMode();
26461 wxPyEndAllowThreads(__tstate);
26462 if (PyErr_Occurred()) SWIG_fail;
26463 }
26464 resultobj = SWIG_From_int(static_cast< int >(result));
26465 return resultobj;
26466 fail:
26467 return NULL;
26468 }
26469
26470
26471 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26472 PyObject *resultobj = 0;
26473 wxWindow *arg1 = (wxWindow *) 0 ;
26474 bool result;
26475 void *argp1 = 0 ;
26476 int res1 = 0 ;
26477 PyObject * obj0 = 0 ;
26478 char * kwnames[] = {
26479 (char *) "win", NULL
26480 };
26481
26482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26484 if (!SWIG_IsOK(res1)) {
26485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26486 }
26487 arg1 = reinterpret_cast< wxWindow * >(argp1);
26488 {
26489 PyThreadState* __tstate = wxPyBeginAllowThreads();
26490 result = (bool)wxIdleEvent::CanSend(arg1);
26491 wxPyEndAllowThreads(__tstate);
26492 if (PyErr_Occurred()) SWIG_fail;
26493 }
26494 {
26495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26496 }
26497 return resultobj;
26498 fail:
26499 return NULL;
26500 }
26501
26502
26503 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26504 PyObject *obj;
26505 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26506 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26507 return SWIG_Py_Void();
26508 }
26509
26510 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26511 return SWIG_Python_InitShadowInstance(args);
26512 }
26513
26514 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26515 PyObject *resultobj = 0;
26516 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26517 int arg2 = (int) 0 ;
26518 wxClipboardTextEvent *result = 0 ;
26519 int val1 ;
26520 int ecode1 = 0 ;
26521 int val2 ;
26522 int ecode2 = 0 ;
26523 PyObject * obj0 = 0 ;
26524 PyObject * obj1 = 0 ;
26525 char * kwnames[] = {
26526 (char *) "type",(char *) "winid", NULL
26527 };
26528
26529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26530 if (obj0) {
26531 ecode1 = SWIG_AsVal_int(obj0, &val1);
26532 if (!SWIG_IsOK(ecode1)) {
26533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26534 }
26535 arg1 = static_cast< wxEventType >(val1);
26536 }
26537 if (obj1) {
26538 ecode2 = SWIG_AsVal_int(obj1, &val2);
26539 if (!SWIG_IsOK(ecode2)) {
26540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26541 }
26542 arg2 = static_cast< int >(val2);
26543 }
26544 {
26545 PyThreadState* __tstate = wxPyBeginAllowThreads();
26546 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26547 wxPyEndAllowThreads(__tstate);
26548 if (PyErr_Occurred()) SWIG_fail;
26549 }
26550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26551 return resultobj;
26552 fail:
26553 return NULL;
26554 }
26555
26556
26557 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26558 PyObject *obj;
26559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26560 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26561 return SWIG_Py_Void();
26562 }
26563
26564 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26565 return SWIG_Python_InitShadowInstance(args);
26566 }
26567
26568 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26569 PyObject *resultobj = 0;
26570 int arg1 = (int) 0 ;
26571 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26572 wxPyEvent *result = 0 ;
26573 int val1 ;
26574 int ecode1 = 0 ;
26575 int val2 ;
26576 int ecode2 = 0 ;
26577 PyObject * obj0 = 0 ;
26578 PyObject * obj1 = 0 ;
26579 char * kwnames[] = {
26580 (char *) "winid",(char *) "eventType", NULL
26581 };
26582
26583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26584 if (obj0) {
26585 ecode1 = SWIG_AsVal_int(obj0, &val1);
26586 if (!SWIG_IsOK(ecode1)) {
26587 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26588 }
26589 arg1 = static_cast< int >(val1);
26590 }
26591 if (obj1) {
26592 ecode2 = SWIG_AsVal_int(obj1, &val2);
26593 if (!SWIG_IsOK(ecode2)) {
26594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26595 }
26596 arg2 = static_cast< wxEventType >(val2);
26597 }
26598 {
26599 PyThreadState* __tstate = wxPyBeginAllowThreads();
26600 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26601 wxPyEndAllowThreads(__tstate);
26602 if (PyErr_Occurred()) SWIG_fail;
26603 }
26604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26605 return resultobj;
26606 fail:
26607 return NULL;
26608 }
26609
26610
26611 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26612 PyObject *resultobj = 0;
26613 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26614 void *argp1 = 0 ;
26615 int res1 = 0 ;
26616 PyObject *swig_obj[1] ;
26617
26618 if (!args) SWIG_fail;
26619 swig_obj[0] = args;
26620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26621 if (!SWIG_IsOK(res1)) {
26622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26623 }
26624 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26625 {
26626 PyThreadState* __tstate = wxPyBeginAllowThreads();
26627 delete arg1;
26628
26629 wxPyEndAllowThreads(__tstate);
26630 if (PyErr_Occurred()) SWIG_fail;
26631 }
26632 resultobj = SWIG_Py_Void();
26633 return resultobj;
26634 fail:
26635 return NULL;
26636 }
26637
26638
26639 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26640 PyObject *resultobj = 0;
26641 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26642 PyObject *arg2 = (PyObject *) 0 ;
26643 void *argp1 = 0 ;
26644 int res1 = 0 ;
26645 PyObject * obj0 = 0 ;
26646 PyObject * obj1 = 0 ;
26647 char * kwnames[] = {
26648 (char *) "self",(char *) "self", NULL
26649 };
26650
26651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26653 if (!SWIG_IsOK(res1)) {
26654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26655 }
26656 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26657 arg2 = obj1;
26658 {
26659 PyThreadState* __tstate = wxPyBeginAllowThreads();
26660 (arg1)->SetSelf(arg2);
26661 wxPyEndAllowThreads(__tstate);
26662 if (PyErr_Occurred()) SWIG_fail;
26663 }
26664 resultobj = SWIG_Py_Void();
26665 return resultobj;
26666 fail:
26667 return NULL;
26668 }
26669
26670
26671 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26672 PyObject *resultobj = 0;
26673 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26674 PyObject *result = 0 ;
26675 void *argp1 = 0 ;
26676 int res1 = 0 ;
26677 PyObject *swig_obj[1] ;
26678
26679 if (!args) SWIG_fail;
26680 swig_obj[0] = args;
26681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26682 if (!SWIG_IsOK(res1)) {
26683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26684 }
26685 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26686 {
26687 PyThreadState* __tstate = wxPyBeginAllowThreads();
26688 result = (PyObject *)(arg1)->GetSelf();
26689 wxPyEndAllowThreads(__tstate);
26690 if (PyErr_Occurred()) SWIG_fail;
26691 }
26692 resultobj = result;
26693 return resultobj;
26694 fail:
26695 return NULL;
26696 }
26697
26698
26699 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26700 PyObject *obj;
26701 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26702 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26703 return SWIG_Py_Void();
26704 }
26705
26706 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26707 return SWIG_Python_InitShadowInstance(args);
26708 }
26709
26710 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26711 PyObject *resultobj = 0;
26712 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26713 int arg2 = (int) 0 ;
26714 wxPyCommandEvent *result = 0 ;
26715 int val1 ;
26716 int ecode1 = 0 ;
26717 int val2 ;
26718 int ecode2 = 0 ;
26719 PyObject * obj0 = 0 ;
26720 PyObject * obj1 = 0 ;
26721 char * kwnames[] = {
26722 (char *) "eventType",(char *) "id", NULL
26723 };
26724
26725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26726 if (obj0) {
26727 ecode1 = SWIG_AsVal_int(obj0, &val1);
26728 if (!SWIG_IsOK(ecode1)) {
26729 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26730 }
26731 arg1 = static_cast< wxEventType >(val1);
26732 }
26733 if (obj1) {
26734 ecode2 = SWIG_AsVal_int(obj1, &val2);
26735 if (!SWIG_IsOK(ecode2)) {
26736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26737 }
26738 arg2 = static_cast< int >(val2);
26739 }
26740 {
26741 PyThreadState* __tstate = wxPyBeginAllowThreads();
26742 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26743 wxPyEndAllowThreads(__tstate);
26744 if (PyErr_Occurred()) SWIG_fail;
26745 }
26746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26747 return resultobj;
26748 fail:
26749 return NULL;
26750 }
26751
26752
26753 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26754 PyObject *resultobj = 0;
26755 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26756 void *argp1 = 0 ;
26757 int res1 = 0 ;
26758 PyObject *swig_obj[1] ;
26759
26760 if (!args) SWIG_fail;
26761 swig_obj[0] = args;
26762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26763 if (!SWIG_IsOK(res1)) {
26764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26765 }
26766 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26767 {
26768 PyThreadState* __tstate = wxPyBeginAllowThreads();
26769 delete arg1;
26770
26771 wxPyEndAllowThreads(__tstate);
26772 if (PyErr_Occurred()) SWIG_fail;
26773 }
26774 resultobj = SWIG_Py_Void();
26775 return resultobj;
26776 fail:
26777 return NULL;
26778 }
26779
26780
26781 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26782 PyObject *resultobj = 0;
26783 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26784 PyObject *arg2 = (PyObject *) 0 ;
26785 void *argp1 = 0 ;
26786 int res1 = 0 ;
26787 PyObject * obj0 = 0 ;
26788 PyObject * obj1 = 0 ;
26789 char * kwnames[] = {
26790 (char *) "self",(char *) "self", NULL
26791 };
26792
26793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26795 if (!SWIG_IsOK(res1)) {
26796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26797 }
26798 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26799 arg2 = obj1;
26800 {
26801 PyThreadState* __tstate = wxPyBeginAllowThreads();
26802 (arg1)->SetSelf(arg2);
26803 wxPyEndAllowThreads(__tstate);
26804 if (PyErr_Occurred()) SWIG_fail;
26805 }
26806 resultobj = SWIG_Py_Void();
26807 return resultobj;
26808 fail:
26809 return NULL;
26810 }
26811
26812
26813 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26814 PyObject *resultobj = 0;
26815 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26816 PyObject *result = 0 ;
26817 void *argp1 = 0 ;
26818 int res1 = 0 ;
26819 PyObject *swig_obj[1] ;
26820
26821 if (!args) SWIG_fail;
26822 swig_obj[0] = args;
26823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26824 if (!SWIG_IsOK(res1)) {
26825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26826 }
26827 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26828 {
26829 PyThreadState* __tstate = wxPyBeginAllowThreads();
26830 result = (PyObject *)(arg1)->GetSelf();
26831 wxPyEndAllowThreads(__tstate);
26832 if (PyErr_Occurred()) SWIG_fail;
26833 }
26834 resultobj = result;
26835 return resultobj;
26836 fail:
26837 return NULL;
26838 }
26839
26840
26841 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26842 PyObject *obj;
26843 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26844 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26845 return SWIG_Py_Void();
26846 }
26847
26848 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26849 return SWIG_Python_InitShadowInstance(args);
26850 }
26851
26852 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26853 PyObject *resultobj = 0;
26854 wxWindow *arg1 = (wxWindow *) 0 ;
26855 wxDateTime *arg2 = 0 ;
26856 wxEventType arg3 ;
26857 wxDateEvent *result = 0 ;
26858 void *argp1 = 0 ;
26859 int res1 = 0 ;
26860 void *argp2 = 0 ;
26861 int res2 = 0 ;
26862 int val3 ;
26863 int ecode3 = 0 ;
26864 PyObject * obj0 = 0 ;
26865 PyObject * obj1 = 0 ;
26866 PyObject * obj2 = 0 ;
26867 char * kwnames[] = {
26868 (char *) "win",(char *) "dt",(char *) "type", NULL
26869 };
26870
26871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26873 if (!SWIG_IsOK(res1)) {
26874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26875 }
26876 arg1 = reinterpret_cast< wxWindow * >(argp1);
26877 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26878 if (!SWIG_IsOK(res2)) {
26879 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26880 }
26881 if (!argp2) {
26882 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26883 }
26884 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26885 ecode3 = SWIG_AsVal_int(obj2, &val3);
26886 if (!SWIG_IsOK(ecode3)) {
26887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26888 }
26889 arg3 = static_cast< wxEventType >(val3);
26890 {
26891 PyThreadState* __tstate = wxPyBeginAllowThreads();
26892 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26893 wxPyEndAllowThreads(__tstate);
26894 if (PyErr_Occurred()) SWIG_fail;
26895 }
26896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26897 return resultobj;
26898 fail:
26899 return NULL;
26900 }
26901
26902
26903 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26904 PyObject *resultobj = 0;
26905 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26906 wxDateTime *result = 0 ;
26907 void *argp1 = 0 ;
26908 int res1 = 0 ;
26909 PyObject *swig_obj[1] ;
26910
26911 if (!args) SWIG_fail;
26912 swig_obj[0] = args;
26913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26914 if (!SWIG_IsOK(res1)) {
26915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26916 }
26917 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26918 {
26919 PyThreadState* __tstate = wxPyBeginAllowThreads();
26920 {
26921 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26922 result = (wxDateTime *) &_result_ref;
26923 }
26924 wxPyEndAllowThreads(__tstate);
26925 if (PyErr_Occurred()) SWIG_fail;
26926 }
26927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26928 return resultobj;
26929 fail:
26930 return NULL;
26931 }
26932
26933
26934 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26935 PyObject *resultobj = 0;
26936 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26937 wxDateTime *arg2 = 0 ;
26938 void *argp1 = 0 ;
26939 int res1 = 0 ;
26940 void *argp2 = 0 ;
26941 int res2 = 0 ;
26942 PyObject * obj0 = 0 ;
26943 PyObject * obj1 = 0 ;
26944 char * kwnames[] = {
26945 (char *) "self",(char *) "date", NULL
26946 };
26947
26948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26950 if (!SWIG_IsOK(res1)) {
26951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26952 }
26953 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26954 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26955 if (!SWIG_IsOK(res2)) {
26956 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26957 }
26958 if (!argp2) {
26959 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26960 }
26961 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26962 {
26963 PyThreadState* __tstate = wxPyBeginAllowThreads();
26964 (arg1)->SetDate((wxDateTime const &)*arg2);
26965 wxPyEndAllowThreads(__tstate);
26966 if (PyErr_Occurred()) SWIG_fail;
26967 }
26968 resultobj = SWIG_Py_Void();
26969 return resultobj;
26970 fail:
26971 return NULL;
26972 }
26973
26974
26975 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26976 PyObject *obj;
26977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26978 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26979 return SWIG_Py_Void();
26980 }
26981
26982 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26983 return SWIG_Python_InitShadowInstance(args);
26984 }
26985
26986 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26987 PyObject *resultobj = 0;
26988 wxPyApp *result = 0 ;
26989
26990 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26991 {
26992 PyThreadState* __tstate = wxPyBeginAllowThreads();
26993 result = (wxPyApp *)new_wxPyApp();
26994 wxPyEndAllowThreads(__tstate);
26995 if (PyErr_Occurred()) SWIG_fail;
26996 }
26997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26998 return resultobj;
26999 fail:
27000 return NULL;
27001 }
27002
27003
27004 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27005 PyObject *resultobj = 0;
27006 wxPyApp *arg1 = (wxPyApp *) 0 ;
27007 void *argp1 = 0 ;
27008 int res1 = 0 ;
27009 PyObject *swig_obj[1] ;
27010
27011 if (!args) SWIG_fail;
27012 swig_obj[0] = args;
27013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27014 if (!SWIG_IsOK(res1)) {
27015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27016 }
27017 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27018 {
27019 PyThreadState* __tstate = wxPyBeginAllowThreads();
27020 delete arg1;
27021
27022 wxPyEndAllowThreads(__tstate);
27023 if (PyErr_Occurred()) SWIG_fail;
27024 }
27025 resultobj = SWIG_Py_Void();
27026 return resultobj;
27027 fail:
27028 return NULL;
27029 }
27030
27031
27032 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27033 PyObject *resultobj = 0;
27034 wxPyApp *arg1 = (wxPyApp *) 0 ;
27035 PyObject *arg2 = (PyObject *) 0 ;
27036 PyObject *arg3 = (PyObject *) 0 ;
27037 bool arg4 ;
27038 void *argp1 = 0 ;
27039 int res1 = 0 ;
27040 bool val4 ;
27041 int ecode4 = 0 ;
27042 PyObject * obj0 = 0 ;
27043 PyObject * obj1 = 0 ;
27044 PyObject * obj2 = 0 ;
27045 PyObject * obj3 = 0 ;
27046 char * kwnames[] = {
27047 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27048 };
27049
27050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27052 if (!SWIG_IsOK(res1)) {
27053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27054 }
27055 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27056 arg2 = obj1;
27057 arg3 = obj2;
27058 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27059 if (!SWIG_IsOK(ecode4)) {
27060 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27061 }
27062 arg4 = static_cast< bool >(val4);
27063 {
27064 PyThreadState* __tstate = wxPyBeginAllowThreads();
27065 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27066 wxPyEndAllowThreads(__tstate);
27067 if (PyErr_Occurred()) SWIG_fail;
27068 }
27069 resultobj = SWIG_Py_Void();
27070 return resultobj;
27071 fail:
27072 return NULL;
27073 }
27074
27075
27076 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27077 PyObject *resultobj = 0;
27078 wxPyApp *arg1 = (wxPyApp *) 0 ;
27079 wxString result;
27080 void *argp1 = 0 ;
27081 int res1 = 0 ;
27082 PyObject *swig_obj[1] ;
27083
27084 if (!args) SWIG_fail;
27085 swig_obj[0] = args;
27086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27087 if (!SWIG_IsOK(res1)) {
27088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27089 }
27090 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27091 {
27092 PyThreadState* __tstate = wxPyBeginAllowThreads();
27093 result = ((wxPyApp const *)arg1)->GetAppName();
27094 wxPyEndAllowThreads(__tstate);
27095 if (PyErr_Occurred()) SWIG_fail;
27096 }
27097 {
27098 #if wxUSE_UNICODE
27099 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27100 #else
27101 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27102 #endif
27103 }
27104 return resultobj;
27105 fail:
27106 return NULL;
27107 }
27108
27109
27110 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27111 PyObject *resultobj = 0;
27112 wxPyApp *arg1 = (wxPyApp *) 0 ;
27113 wxString *arg2 = 0 ;
27114 void *argp1 = 0 ;
27115 int res1 = 0 ;
27116 bool temp2 = false ;
27117 PyObject * obj0 = 0 ;
27118 PyObject * obj1 = 0 ;
27119 char * kwnames[] = {
27120 (char *) "self",(char *) "name", NULL
27121 };
27122
27123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27125 if (!SWIG_IsOK(res1)) {
27126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27127 }
27128 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27129 {
27130 arg2 = wxString_in_helper(obj1);
27131 if (arg2 == NULL) SWIG_fail;
27132 temp2 = true;
27133 }
27134 {
27135 PyThreadState* __tstate = wxPyBeginAllowThreads();
27136 (arg1)->SetAppName((wxString const &)*arg2);
27137 wxPyEndAllowThreads(__tstate);
27138 if (PyErr_Occurred()) SWIG_fail;
27139 }
27140 resultobj = SWIG_Py_Void();
27141 {
27142 if (temp2)
27143 delete arg2;
27144 }
27145 return resultobj;
27146 fail:
27147 {
27148 if (temp2)
27149 delete arg2;
27150 }
27151 return NULL;
27152 }
27153
27154
27155 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27156 PyObject *resultobj = 0;
27157 wxPyApp *arg1 = (wxPyApp *) 0 ;
27158 wxString result;
27159 void *argp1 = 0 ;
27160 int res1 = 0 ;
27161 PyObject *swig_obj[1] ;
27162
27163 if (!args) SWIG_fail;
27164 swig_obj[0] = args;
27165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27166 if (!SWIG_IsOK(res1)) {
27167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27168 }
27169 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27170 {
27171 PyThreadState* __tstate = wxPyBeginAllowThreads();
27172 result = ((wxPyApp const *)arg1)->GetClassName();
27173 wxPyEndAllowThreads(__tstate);
27174 if (PyErr_Occurred()) SWIG_fail;
27175 }
27176 {
27177 #if wxUSE_UNICODE
27178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27179 #else
27180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27181 #endif
27182 }
27183 return resultobj;
27184 fail:
27185 return NULL;
27186 }
27187
27188
27189 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27190 PyObject *resultobj = 0;
27191 wxPyApp *arg1 = (wxPyApp *) 0 ;
27192 wxString *arg2 = 0 ;
27193 void *argp1 = 0 ;
27194 int res1 = 0 ;
27195 bool temp2 = false ;
27196 PyObject * obj0 = 0 ;
27197 PyObject * obj1 = 0 ;
27198 char * kwnames[] = {
27199 (char *) "self",(char *) "name", NULL
27200 };
27201
27202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27204 if (!SWIG_IsOK(res1)) {
27205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27206 }
27207 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27208 {
27209 arg2 = wxString_in_helper(obj1);
27210 if (arg2 == NULL) SWIG_fail;
27211 temp2 = true;
27212 }
27213 {
27214 PyThreadState* __tstate = wxPyBeginAllowThreads();
27215 (arg1)->SetClassName((wxString const &)*arg2);
27216 wxPyEndAllowThreads(__tstate);
27217 if (PyErr_Occurred()) SWIG_fail;
27218 }
27219 resultobj = SWIG_Py_Void();
27220 {
27221 if (temp2)
27222 delete arg2;
27223 }
27224 return resultobj;
27225 fail:
27226 {
27227 if (temp2)
27228 delete arg2;
27229 }
27230 return NULL;
27231 }
27232
27233
27234 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27235 PyObject *resultobj = 0;
27236 wxPyApp *arg1 = (wxPyApp *) 0 ;
27237 wxString *result = 0 ;
27238 void *argp1 = 0 ;
27239 int res1 = 0 ;
27240 PyObject *swig_obj[1] ;
27241
27242 if (!args) SWIG_fail;
27243 swig_obj[0] = args;
27244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27245 if (!SWIG_IsOK(res1)) {
27246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27247 }
27248 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27249 {
27250 PyThreadState* __tstate = wxPyBeginAllowThreads();
27251 {
27252 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27253 result = (wxString *) &_result_ref;
27254 }
27255 wxPyEndAllowThreads(__tstate);
27256 if (PyErr_Occurred()) SWIG_fail;
27257 }
27258 {
27259 #if wxUSE_UNICODE
27260 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27261 #else
27262 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27263 #endif
27264 }
27265 return resultobj;
27266 fail:
27267 return NULL;
27268 }
27269
27270
27271 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27272 PyObject *resultobj = 0;
27273 wxPyApp *arg1 = (wxPyApp *) 0 ;
27274 wxString *arg2 = 0 ;
27275 void *argp1 = 0 ;
27276 int res1 = 0 ;
27277 bool temp2 = false ;
27278 PyObject * obj0 = 0 ;
27279 PyObject * obj1 = 0 ;
27280 char * kwnames[] = {
27281 (char *) "self",(char *) "name", NULL
27282 };
27283
27284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27286 if (!SWIG_IsOK(res1)) {
27287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27288 }
27289 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27290 {
27291 arg2 = wxString_in_helper(obj1);
27292 if (arg2 == NULL) SWIG_fail;
27293 temp2 = true;
27294 }
27295 {
27296 PyThreadState* __tstate = wxPyBeginAllowThreads();
27297 (arg1)->SetVendorName((wxString const &)*arg2);
27298 wxPyEndAllowThreads(__tstate);
27299 if (PyErr_Occurred()) SWIG_fail;
27300 }
27301 resultobj = SWIG_Py_Void();
27302 {
27303 if (temp2)
27304 delete arg2;
27305 }
27306 return resultobj;
27307 fail:
27308 {
27309 if (temp2)
27310 delete arg2;
27311 }
27312 return NULL;
27313 }
27314
27315
27316 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27317 PyObject *resultobj = 0;
27318 wxPyApp *arg1 = (wxPyApp *) 0 ;
27319 wxAppTraits *result = 0 ;
27320 void *argp1 = 0 ;
27321 int res1 = 0 ;
27322 PyObject *swig_obj[1] ;
27323
27324 if (!args) SWIG_fail;
27325 swig_obj[0] = args;
27326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27327 if (!SWIG_IsOK(res1)) {
27328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27329 }
27330 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27331 {
27332 PyThreadState* __tstate = wxPyBeginAllowThreads();
27333 result = (wxAppTraits *)(arg1)->GetTraits();
27334 wxPyEndAllowThreads(__tstate);
27335 if (PyErr_Occurred()) SWIG_fail;
27336 }
27337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27338 return resultobj;
27339 fail:
27340 return NULL;
27341 }
27342
27343
27344 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27345 PyObject *resultobj = 0;
27346 wxPyApp *arg1 = (wxPyApp *) 0 ;
27347 void *argp1 = 0 ;
27348 int res1 = 0 ;
27349 PyObject *swig_obj[1] ;
27350
27351 if (!args) SWIG_fail;
27352 swig_obj[0] = args;
27353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27354 if (!SWIG_IsOK(res1)) {
27355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27356 }
27357 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27358 {
27359 PyThreadState* __tstate = wxPyBeginAllowThreads();
27360 (arg1)->ProcessPendingEvents();
27361 wxPyEndAllowThreads(__tstate);
27362 if (PyErr_Occurred()) SWIG_fail;
27363 }
27364 resultobj = SWIG_Py_Void();
27365 return resultobj;
27366 fail:
27367 return NULL;
27368 }
27369
27370
27371 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27372 PyObject *resultobj = 0;
27373 wxPyApp *arg1 = (wxPyApp *) 0 ;
27374 bool arg2 = (bool) false ;
27375 bool result;
27376 void *argp1 = 0 ;
27377 int res1 = 0 ;
27378 bool val2 ;
27379 int ecode2 = 0 ;
27380 PyObject * obj0 = 0 ;
27381 PyObject * obj1 = 0 ;
27382 char * kwnames[] = {
27383 (char *) "self",(char *) "onlyIfNeeded", NULL
27384 };
27385
27386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27388 if (!SWIG_IsOK(res1)) {
27389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27390 }
27391 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27392 if (obj1) {
27393 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27394 if (!SWIG_IsOK(ecode2)) {
27395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27396 }
27397 arg2 = static_cast< bool >(val2);
27398 }
27399 {
27400 PyThreadState* __tstate = wxPyBeginAllowThreads();
27401 result = (bool)(arg1)->Yield(arg2);
27402 wxPyEndAllowThreads(__tstate);
27403 if (PyErr_Occurred()) SWIG_fail;
27404 }
27405 {
27406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27407 }
27408 return resultobj;
27409 fail:
27410 return NULL;
27411 }
27412
27413
27414 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27415 PyObject *resultobj = 0;
27416 wxPyApp *arg1 = (wxPyApp *) 0 ;
27417 void *argp1 = 0 ;
27418 int res1 = 0 ;
27419 PyObject *swig_obj[1] ;
27420
27421 if (!args) SWIG_fail;
27422 swig_obj[0] = args;
27423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27424 if (!SWIG_IsOK(res1)) {
27425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27426 }
27427 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27428 {
27429 PyThreadState* __tstate = wxPyBeginAllowThreads();
27430 (arg1)->WakeUpIdle();
27431 wxPyEndAllowThreads(__tstate);
27432 if (PyErr_Occurred()) SWIG_fail;
27433 }
27434 resultobj = SWIG_Py_Void();
27435 return resultobj;
27436 fail:
27437 return NULL;
27438 }
27439
27440
27441 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27442 PyObject *resultobj = 0;
27443 bool result;
27444
27445 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27446 {
27447 PyThreadState* __tstate = wxPyBeginAllowThreads();
27448 result = (bool)wxPyApp::IsMainLoopRunning();
27449 wxPyEndAllowThreads(__tstate);
27450 if (PyErr_Occurred()) SWIG_fail;
27451 }
27452 {
27453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27454 }
27455 return resultobj;
27456 fail:
27457 return NULL;
27458 }
27459
27460
27461 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27462 PyObject *resultobj = 0;
27463 wxPyApp *arg1 = (wxPyApp *) 0 ;
27464 int result;
27465 void *argp1 = 0 ;
27466 int res1 = 0 ;
27467 PyObject *swig_obj[1] ;
27468
27469 if (!args) SWIG_fail;
27470 swig_obj[0] = args;
27471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27472 if (!SWIG_IsOK(res1)) {
27473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27474 }
27475 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27476 {
27477 PyThreadState* __tstate = wxPyBeginAllowThreads();
27478 result = (int)(arg1)->MainLoop();
27479 wxPyEndAllowThreads(__tstate);
27480 if (PyErr_Occurred()) SWIG_fail;
27481 }
27482 resultobj = SWIG_From_int(static_cast< int >(result));
27483 return resultobj;
27484 fail:
27485 return NULL;
27486 }
27487
27488
27489 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27490 PyObject *resultobj = 0;
27491 wxPyApp *arg1 = (wxPyApp *) 0 ;
27492 void *argp1 = 0 ;
27493 int res1 = 0 ;
27494 PyObject *swig_obj[1] ;
27495
27496 if (!args) SWIG_fail;
27497 swig_obj[0] = args;
27498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27499 if (!SWIG_IsOK(res1)) {
27500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27501 }
27502 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27503 {
27504 PyThreadState* __tstate = wxPyBeginAllowThreads();
27505 (arg1)->Exit();
27506 wxPyEndAllowThreads(__tstate);
27507 if (PyErr_Occurred()) SWIG_fail;
27508 }
27509 resultobj = SWIG_Py_Void();
27510 return resultobj;
27511 fail:
27512 return NULL;
27513 }
27514
27515
27516 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27517 PyObject *resultobj = 0;
27518 wxPyApp *arg1 = (wxPyApp *) 0 ;
27519 void *argp1 = 0 ;
27520 int res1 = 0 ;
27521 PyObject *swig_obj[1] ;
27522
27523 if (!args) SWIG_fail;
27524 swig_obj[0] = args;
27525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27526 if (!SWIG_IsOK(res1)) {
27527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27528 }
27529 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27530 {
27531 PyThreadState* __tstate = wxPyBeginAllowThreads();
27532 (arg1)->ExitMainLoop();
27533 wxPyEndAllowThreads(__tstate);
27534 if (PyErr_Occurred()) SWIG_fail;
27535 }
27536 resultobj = SWIG_Py_Void();
27537 return resultobj;
27538 fail:
27539 return NULL;
27540 }
27541
27542
27543 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27544 PyObject *resultobj = 0;
27545 wxPyApp *arg1 = (wxPyApp *) 0 ;
27546 bool result;
27547 void *argp1 = 0 ;
27548 int res1 = 0 ;
27549 PyObject *swig_obj[1] ;
27550
27551 if (!args) SWIG_fail;
27552 swig_obj[0] = args;
27553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27554 if (!SWIG_IsOK(res1)) {
27555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27556 }
27557 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27558 {
27559 PyThreadState* __tstate = wxPyBeginAllowThreads();
27560 result = (bool)(arg1)->Pending();
27561 wxPyEndAllowThreads(__tstate);
27562 if (PyErr_Occurred()) SWIG_fail;
27563 }
27564 {
27565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27566 }
27567 return resultobj;
27568 fail:
27569 return NULL;
27570 }
27571
27572
27573 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27574 PyObject *resultobj = 0;
27575 wxPyApp *arg1 = (wxPyApp *) 0 ;
27576 bool result;
27577 void *argp1 = 0 ;
27578 int res1 = 0 ;
27579 PyObject *swig_obj[1] ;
27580
27581 if (!args) SWIG_fail;
27582 swig_obj[0] = args;
27583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27584 if (!SWIG_IsOK(res1)) {
27585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27586 }
27587 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27588 {
27589 PyThreadState* __tstate = wxPyBeginAllowThreads();
27590 result = (bool)(arg1)->Dispatch();
27591 wxPyEndAllowThreads(__tstate);
27592 if (PyErr_Occurred()) SWIG_fail;
27593 }
27594 {
27595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27596 }
27597 return resultobj;
27598 fail:
27599 return NULL;
27600 }
27601
27602
27603 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27604 PyObject *resultobj = 0;
27605 wxPyApp *arg1 = (wxPyApp *) 0 ;
27606 bool result;
27607 void *argp1 = 0 ;
27608 int res1 = 0 ;
27609 PyObject *swig_obj[1] ;
27610
27611 if (!args) SWIG_fail;
27612 swig_obj[0] = args;
27613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27614 if (!SWIG_IsOK(res1)) {
27615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27616 }
27617 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27618 {
27619 PyThreadState* __tstate = wxPyBeginAllowThreads();
27620 result = (bool)(arg1)->ProcessIdle();
27621 wxPyEndAllowThreads(__tstate);
27622 if (PyErr_Occurred()) SWIG_fail;
27623 }
27624 {
27625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27626 }
27627 return resultobj;
27628 fail:
27629 return NULL;
27630 }
27631
27632
27633 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27634 PyObject *resultobj = 0;
27635 wxPyApp *arg1 = (wxPyApp *) 0 ;
27636 wxWindow *arg2 = (wxWindow *) 0 ;
27637 wxIdleEvent *arg3 = 0 ;
27638 bool result;
27639 void *argp1 = 0 ;
27640 int res1 = 0 ;
27641 void *argp2 = 0 ;
27642 int res2 = 0 ;
27643 void *argp3 = 0 ;
27644 int res3 = 0 ;
27645 PyObject * obj0 = 0 ;
27646 PyObject * obj1 = 0 ;
27647 PyObject * obj2 = 0 ;
27648 char * kwnames[] = {
27649 (char *) "self",(char *) "win",(char *) "event", NULL
27650 };
27651
27652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27654 if (!SWIG_IsOK(res1)) {
27655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27656 }
27657 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27658 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27659 if (!SWIG_IsOK(res2)) {
27660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27661 }
27662 arg2 = reinterpret_cast< wxWindow * >(argp2);
27663 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27664 if (!SWIG_IsOK(res3)) {
27665 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27666 }
27667 if (!argp3) {
27668 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27669 }
27670 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27671 {
27672 PyThreadState* __tstate = wxPyBeginAllowThreads();
27673 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27674 wxPyEndAllowThreads(__tstate);
27675 if (PyErr_Occurred()) SWIG_fail;
27676 }
27677 {
27678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27679 }
27680 return resultobj;
27681 fail:
27682 return NULL;
27683 }
27684
27685
27686 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27687 PyObject *resultobj = 0;
27688 wxPyApp *arg1 = (wxPyApp *) 0 ;
27689 bool result;
27690 void *argp1 = 0 ;
27691 int res1 = 0 ;
27692 PyObject *swig_obj[1] ;
27693
27694 if (!args) SWIG_fail;
27695 swig_obj[0] = args;
27696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27697 if (!SWIG_IsOK(res1)) {
27698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27699 }
27700 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27701 {
27702 PyThreadState* __tstate = wxPyBeginAllowThreads();
27703 result = (bool)((wxPyApp const *)arg1)->IsActive();
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_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27717 PyObject *resultobj = 0;
27718 wxPyApp *arg1 = (wxPyApp *) 0 ;
27719 wxWindow *arg2 = (wxWindow *) 0 ;
27720 void *argp1 = 0 ;
27721 int res1 = 0 ;
27722 void *argp2 = 0 ;
27723 int res2 = 0 ;
27724 PyObject * obj0 = 0 ;
27725 PyObject * obj1 = 0 ;
27726 char * kwnames[] = {
27727 (char *) "self",(char *) "win", NULL
27728 };
27729
27730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27732 if (!SWIG_IsOK(res1)) {
27733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27734 }
27735 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27736 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27737 if (!SWIG_IsOK(res2)) {
27738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27739 }
27740 arg2 = reinterpret_cast< wxWindow * >(argp2);
27741 {
27742 PyThreadState* __tstate = wxPyBeginAllowThreads();
27743 (arg1)->SetTopWindow(arg2);
27744 wxPyEndAllowThreads(__tstate);
27745 if (PyErr_Occurred()) SWIG_fail;
27746 }
27747 resultobj = SWIG_Py_Void();
27748 return resultobj;
27749 fail:
27750 return NULL;
27751 }
27752
27753
27754 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27755 PyObject *resultobj = 0;
27756 wxPyApp *arg1 = (wxPyApp *) 0 ;
27757 wxWindow *result = 0 ;
27758 void *argp1 = 0 ;
27759 int res1 = 0 ;
27760 PyObject *swig_obj[1] ;
27761
27762 if (!args) SWIG_fail;
27763 swig_obj[0] = args;
27764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27765 if (!SWIG_IsOK(res1)) {
27766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27767 }
27768 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27769 {
27770 PyThreadState* __tstate = wxPyBeginAllowThreads();
27771 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27772 wxPyEndAllowThreads(__tstate);
27773 if (PyErr_Occurred()) SWIG_fail;
27774 }
27775 {
27776 resultobj = wxPyMake_wxObject(result, (bool)0);
27777 }
27778 return resultobj;
27779 fail:
27780 return NULL;
27781 }
27782
27783
27784 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27785 PyObject *resultobj = 0;
27786 wxPyApp *arg1 = (wxPyApp *) 0 ;
27787 bool arg2 ;
27788 void *argp1 = 0 ;
27789 int res1 = 0 ;
27790 bool val2 ;
27791 int ecode2 = 0 ;
27792 PyObject * obj0 = 0 ;
27793 PyObject * obj1 = 0 ;
27794 char * kwnames[] = {
27795 (char *) "self",(char *) "flag", NULL
27796 };
27797
27798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27800 if (!SWIG_IsOK(res1)) {
27801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27802 }
27803 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27804 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27805 if (!SWIG_IsOK(ecode2)) {
27806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27807 }
27808 arg2 = static_cast< bool >(val2);
27809 {
27810 PyThreadState* __tstate = wxPyBeginAllowThreads();
27811 (arg1)->SetExitOnFrameDelete(arg2);
27812 wxPyEndAllowThreads(__tstate);
27813 if (PyErr_Occurred()) SWIG_fail;
27814 }
27815 resultobj = SWIG_Py_Void();
27816 return resultobj;
27817 fail:
27818 return NULL;
27819 }
27820
27821
27822 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27823 PyObject *resultobj = 0;
27824 wxPyApp *arg1 = (wxPyApp *) 0 ;
27825 bool result;
27826 void *argp1 = 0 ;
27827 int res1 = 0 ;
27828 PyObject *swig_obj[1] ;
27829
27830 if (!args) SWIG_fail;
27831 swig_obj[0] = args;
27832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27833 if (!SWIG_IsOK(res1)) {
27834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27835 }
27836 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27837 {
27838 PyThreadState* __tstate = wxPyBeginAllowThreads();
27839 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27840 wxPyEndAllowThreads(__tstate);
27841 if (PyErr_Occurred()) SWIG_fail;
27842 }
27843 {
27844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27845 }
27846 return resultobj;
27847 fail:
27848 return NULL;
27849 }
27850
27851
27852 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27853 PyObject *resultobj = 0;
27854 wxPyApp *arg1 = (wxPyApp *) 0 ;
27855 bool arg2 ;
27856 void *argp1 = 0 ;
27857 int res1 = 0 ;
27858 bool val2 ;
27859 int ecode2 = 0 ;
27860 PyObject * obj0 = 0 ;
27861 PyObject * obj1 = 0 ;
27862 char * kwnames[] = {
27863 (char *) "self",(char *) "flag", NULL
27864 };
27865
27866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27868 if (!SWIG_IsOK(res1)) {
27869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27870 }
27871 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27872 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27873 if (!SWIG_IsOK(ecode2)) {
27874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27875 }
27876 arg2 = static_cast< bool >(val2);
27877 {
27878 PyThreadState* __tstate = wxPyBeginAllowThreads();
27879 (arg1)->SetUseBestVisual(arg2);
27880 wxPyEndAllowThreads(__tstate);
27881 if (PyErr_Occurred()) SWIG_fail;
27882 }
27883 resultobj = SWIG_Py_Void();
27884 return resultobj;
27885 fail:
27886 return NULL;
27887 }
27888
27889
27890 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27891 PyObject *resultobj = 0;
27892 wxPyApp *arg1 = (wxPyApp *) 0 ;
27893 bool result;
27894 void *argp1 = 0 ;
27895 int res1 = 0 ;
27896 PyObject *swig_obj[1] ;
27897
27898 if (!args) SWIG_fail;
27899 swig_obj[0] = args;
27900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27901 if (!SWIG_IsOK(res1)) {
27902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27903 }
27904 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27905 {
27906 PyThreadState* __tstate = wxPyBeginAllowThreads();
27907 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27908 wxPyEndAllowThreads(__tstate);
27909 if (PyErr_Occurred()) SWIG_fail;
27910 }
27911 {
27912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27913 }
27914 return resultobj;
27915 fail:
27916 return NULL;
27917 }
27918
27919
27920 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27921 PyObject *resultobj = 0;
27922 wxPyApp *arg1 = (wxPyApp *) 0 ;
27923 int arg2 ;
27924 void *argp1 = 0 ;
27925 int res1 = 0 ;
27926 int val2 ;
27927 int ecode2 = 0 ;
27928 PyObject * obj0 = 0 ;
27929 PyObject * obj1 = 0 ;
27930 char * kwnames[] = {
27931 (char *) "self",(char *) "mode", NULL
27932 };
27933
27934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27936 if (!SWIG_IsOK(res1)) {
27937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27938 }
27939 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27940 ecode2 = SWIG_AsVal_int(obj1, &val2);
27941 if (!SWIG_IsOK(ecode2)) {
27942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27943 }
27944 arg2 = static_cast< int >(val2);
27945 {
27946 PyThreadState* __tstate = wxPyBeginAllowThreads();
27947 (arg1)->SetPrintMode(arg2);
27948 wxPyEndAllowThreads(__tstate);
27949 if (PyErr_Occurred()) SWIG_fail;
27950 }
27951 resultobj = SWIG_Py_Void();
27952 return resultobj;
27953 fail:
27954 return NULL;
27955 }
27956
27957
27958 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27959 PyObject *resultobj = 0;
27960 wxPyApp *arg1 = (wxPyApp *) 0 ;
27961 int result;
27962 void *argp1 = 0 ;
27963 int res1 = 0 ;
27964 PyObject *swig_obj[1] ;
27965
27966 if (!args) SWIG_fail;
27967 swig_obj[0] = args;
27968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27969 if (!SWIG_IsOK(res1)) {
27970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27971 }
27972 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27973 {
27974 PyThreadState* __tstate = wxPyBeginAllowThreads();
27975 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27976 wxPyEndAllowThreads(__tstate);
27977 if (PyErr_Occurred()) SWIG_fail;
27978 }
27979 resultobj = SWIG_From_int(static_cast< int >(result));
27980 return resultobj;
27981 fail:
27982 return NULL;
27983 }
27984
27985
27986 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27987 PyObject *resultobj = 0;
27988 wxPyApp *arg1 = (wxPyApp *) 0 ;
27989 int arg2 ;
27990 void *argp1 = 0 ;
27991 int res1 = 0 ;
27992 int val2 ;
27993 int ecode2 = 0 ;
27994 PyObject * obj0 = 0 ;
27995 PyObject * obj1 = 0 ;
27996 char * kwnames[] = {
27997 (char *) "self",(char *) "mode", NULL
27998 };
27999
28000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28002 if (!SWIG_IsOK(res1)) {
28003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28004 }
28005 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28006 ecode2 = SWIG_AsVal_int(obj1, &val2);
28007 if (!SWIG_IsOK(ecode2)) {
28008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28009 }
28010 arg2 = static_cast< int >(val2);
28011 {
28012 PyThreadState* __tstate = wxPyBeginAllowThreads();
28013 (arg1)->SetAssertMode(arg2);
28014 wxPyEndAllowThreads(__tstate);
28015 if (PyErr_Occurred()) SWIG_fail;
28016 }
28017 resultobj = SWIG_Py_Void();
28018 return resultobj;
28019 fail:
28020 return NULL;
28021 }
28022
28023
28024 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28025 PyObject *resultobj = 0;
28026 wxPyApp *arg1 = (wxPyApp *) 0 ;
28027 int result;
28028 void *argp1 = 0 ;
28029 int res1 = 0 ;
28030 PyObject *swig_obj[1] ;
28031
28032 if (!args) SWIG_fail;
28033 swig_obj[0] = args;
28034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28035 if (!SWIG_IsOK(res1)) {
28036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28037 }
28038 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28039 {
28040 PyThreadState* __tstate = wxPyBeginAllowThreads();
28041 result = (int)(arg1)->GetAssertMode();
28042 wxPyEndAllowThreads(__tstate);
28043 if (PyErr_Occurred()) SWIG_fail;
28044 }
28045 resultobj = SWIG_From_int(static_cast< int >(result));
28046 return resultobj;
28047 fail:
28048 return NULL;
28049 }
28050
28051
28052 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28053 PyObject *resultobj = 0;
28054 bool result;
28055
28056 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28057 {
28058 PyThreadState* __tstate = wxPyBeginAllowThreads();
28059 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28060 wxPyEndAllowThreads(__tstate);
28061 if (PyErr_Occurred()) SWIG_fail;
28062 }
28063 {
28064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28065 }
28066 return resultobj;
28067 fail:
28068 return NULL;
28069 }
28070
28071
28072 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28073 PyObject *resultobj = 0;
28074 long result;
28075
28076 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28077 {
28078 PyThreadState* __tstate = wxPyBeginAllowThreads();
28079 result = (long)wxPyApp::GetMacAboutMenuItemId();
28080 wxPyEndAllowThreads(__tstate);
28081 if (PyErr_Occurred()) SWIG_fail;
28082 }
28083 resultobj = SWIG_From_long(static_cast< long >(result));
28084 return resultobj;
28085 fail:
28086 return NULL;
28087 }
28088
28089
28090 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28091 PyObject *resultobj = 0;
28092 long result;
28093
28094 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28095 {
28096 PyThreadState* __tstate = wxPyBeginAllowThreads();
28097 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28098 wxPyEndAllowThreads(__tstate);
28099 if (PyErr_Occurred()) SWIG_fail;
28100 }
28101 resultobj = SWIG_From_long(static_cast< long >(result));
28102 return resultobj;
28103 fail:
28104 return NULL;
28105 }
28106
28107
28108 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28109 PyObject *resultobj = 0;
28110 long result;
28111
28112 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28113 {
28114 PyThreadState* __tstate = wxPyBeginAllowThreads();
28115 result = (long)wxPyApp::GetMacExitMenuItemId();
28116 wxPyEndAllowThreads(__tstate);
28117 if (PyErr_Occurred()) SWIG_fail;
28118 }
28119 resultobj = SWIG_From_long(static_cast< long >(result));
28120 return resultobj;
28121 fail:
28122 return NULL;
28123 }
28124
28125
28126 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28127 PyObject *resultobj = 0;
28128 wxString result;
28129
28130 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28131 {
28132 PyThreadState* __tstate = wxPyBeginAllowThreads();
28133 result = wxPyApp::GetMacHelpMenuTitleName();
28134 wxPyEndAllowThreads(__tstate);
28135 if (PyErr_Occurred()) SWIG_fail;
28136 }
28137 {
28138 #if wxUSE_UNICODE
28139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28140 #else
28141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28142 #endif
28143 }
28144 return resultobj;
28145 fail:
28146 return NULL;
28147 }
28148
28149
28150 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28151 PyObject *resultobj = 0;
28152 bool arg1 ;
28153 bool val1 ;
28154 int ecode1 = 0 ;
28155 PyObject * obj0 = 0 ;
28156 char * kwnames[] = {
28157 (char *) "val", NULL
28158 };
28159
28160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28161 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28162 if (!SWIG_IsOK(ecode1)) {
28163 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28164 }
28165 arg1 = static_cast< bool >(val1);
28166 {
28167 PyThreadState* __tstate = wxPyBeginAllowThreads();
28168 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28169 wxPyEndAllowThreads(__tstate);
28170 if (PyErr_Occurred()) SWIG_fail;
28171 }
28172 resultobj = SWIG_Py_Void();
28173 return resultobj;
28174 fail:
28175 return NULL;
28176 }
28177
28178
28179 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28180 PyObject *resultobj = 0;
28181 long arg1 ;
28182 long val1 ;
28183 int ecode1 = 0 ;
28184 PyObject * obj0 = 0 ;
28185 char * kwnames[] = {
28186 (char *) "val", NULL
28187 };
28188
28189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28190 ecode1 = SWIG_AsVal_long(obj0, &val1);
28191 if (!SWIG_IsOK(ecode1)) {
28192 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28193 }
28194 arg1 = static_cast< long >(val1);
28195 {
28196 PyThreadState* __tstate = wxPyBeginAllowThreads();
28197 wxPyApp::SetMacAboutMenuItemId(arg1);
28198 wxPyEndAllowThreads(__tstate);
28199 if (PyErr_Occurred()) SWIG_fail;
28200 }
28201 resultobj = SWIG_Py_Void();
28202 return resultobj;
28203 fail:
28204 return NULL;
28205 }
28206
28207
28208 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28209 PyObject *resultobj = 0;
28210 long arg1 ;
28211 long val1 ;
28212 int ecode1 = 0 ;
28213 PyObject * obj0 = 0 ;
28214 char * kwnames[] = {
28215 (char *) "val", NULL
28216 };
28217
28218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28219 ecode1 = SWIG_AsVal_long(obj0, &val1);
28220 if (!SWIG_IsOK(ecode1)) {
28221 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28222 }
28223 arg1 = static_cast< long >(val1);
28224 {
28225 PyThreadState* __tstate = wxPyBeginAllowThreads();
28226 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28227 wxPyEndAllowThreads(__tstate);
28228 if (PyErr_Occurred()) SWIG_fail;
28229 }
28230 resultobj = SWIG_Py_Void();
28231 return resultobj;
28232 fail:
28233 return NULL;
28234 }
28235
28236
28237 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28238 PyObject *resultobj = 0;
28239 long arg1 ;
28240 long val1 ;
28241 int ecode1 = 0 ;
28242 PyObject * obj0 = 0 ;
28243 char * kwnames[] = {
28244 (char *) "val", NULL
28245 };
28246
28247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28248 ecode1 = SWIG_AsVal_long(obj0, &val1);
28249 if (!SWIG_IsOK(ecode1)) {
28250 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28251 }
28252 arg1 = static_cast< long >(val1);
28253 {
28254 PyThreadState* __tstate = wxPyBeginAllowThreads();
28255 wxPyApp::SetMacExitMenuItemId(arg1);
28256 wxPyEndAllowThreads(__tstate);
28257 if (PyErr_Occurred()) SWIG_fail;
28258 }
28259 resultobj = SWIG_Py_Void();
28260 return resultobj;
28261 fail:
28262 return NULL;
28263 }
28264
28265
28266 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28267 PyObject *resultobj = 0;
28268 wxString *arg1 = 0 ;
28269 bool temp1 = false ;
28270 PyObject * obj0 = 0 ;
28271 char * kwnames[] = {
28272 (char *) "val", NULL
28273 };
28274
28275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28276 {
28277 arg1 = wxString_in_helper(obj0);
28278 if (arg1 == NULL) SWIG_fail;
28279 temp1 = true;
28280 }
28281 {
28282 PyThreadState* __tstate = wxPyBeginAllowThreads();
28283 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28284 wxPyEndAllowThreads(__tstate);
28285 if (PyErr_Occurred()) SWIG_fail;
28286 }
28287 resultobj = SWIG_Py_Void();
28288 {
28289 if (temp1)
28290 delete arg1;
28291 }
28292 return resultobj;
28293 fail:
28294 {
28295 if (temp1)
28296 delete arg1;
28297 }
28298 return NULL;
28299 }
28300
28301
28302 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28303 PyObject *resultobj = 0;
28304 wxPyApp *arg1 = (wxPyApp *) 0 ;
28305 void *argp1 = 0 ;
28306 int res1 = 0 ;
28307 PyObject *swig_obj[1] ;
28308
28309 if (!args) SWIG_fail;
28310 swig_obj[0] = args;
28311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28312 if (!SWIG_IsOK(res1)) {
28313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28314 }
28315 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28316 {
28317 PyThreadState* __tstate = wxPyBeginAllowThreads();
28318 (arg1)->_BootstrapApp();
28319 wxPyEndAllowThreads(__tstate);
28320 if (PyErr_Occurred()) SWIG_fail;
28321 }
28322 resultobj = SWIG_Py_Void();
28323 return resultobj;
28324 fail:
28325 return NULL;
28326 }
28327
28328
28329 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28330 PyObject *resultobj = 0;
28331 int result;
28332
28333 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28334 {
28335 PyThreadState* __tstate = wxPyBeginAllowThreads();
28336 result = (int)wxPyApp::GetComCtl32Version();
28337 wxPyEndAllowThreads(__tstate);
28338 if (PyErr_Occurred()) SWIG_fail;
28339 }
28340 resultobj = SWIG_From_int(static_cast< int >(result));
28341 return resultobj;
28342 fail:
28343 return NULL;
28344 }
28345
28346
28347 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28348 PyObject *obj;
28349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28350 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28351 return SWIG_Py_Void();
28352 }
28353
28354 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28355 return SWIG_Python_InitShadowInstance(args);
28356 }
28357
28358 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28359 PyObject *resultobj = 0;
28360
28361 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28362 {
28363 PyThreadState* __tstate = wxPyBeginAllowThreads();
28364 wxExit();
28365 wxPyEndAllowThreads(__tstate);
28366 if (PyErr_Occurred()) SWIG_fail;
28367 }
28368 resultobj = SWIG_Py_Void();
28369 return resultobj;
28370 fail:
28371 return NULL;
28372 }
28373
28374
28375 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28376 PyObject *resultobj = 0;
28377 bool result;
28378
28379 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28380 {
28381 PyThreadState* __tstate = wxPyBeginAllowThreads();
28382 result = (bool)wxYield();
28383 wxPyEndAllowThreads(__tstate);
28384 if (PyErr_Occurred()) SWIG_fail;
28385 }
28386 {
28387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28388 }
28389 return resultobj;
28390 fail:
28391 return NULL;
28392 }
28393
28394
28395 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28396 PyObject *resultobj = 0;
28397 bool result;
28398
28399 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28400 {
28401 PyThreadState* __tstate = wxPyBeginAllowThreads();
28402 result = (bool)wxYieldIfNeeded();
28403 wxPyEndAllowThreads(__tstate);
28404 if (PyErr_Occurred()) SWIG_fail;
28405 }
28406 {
28407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28408 }
28409 return resultobj;
28410 fail:
28411 return NULL;
28412 }
28413
28414
28415 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28416 PyObject *resultobj = 0;
28417 wxWindow *arg1 = (wxWindow *) NULL ;
28418 bool arg2 = (bool) false ;
28419 bool result;
28420 void *argp1 = 0 ;
28421 int res1 = 0 ;
28422 bool val2 ;
28423 int ecode2 = 0 ;
28424 PyObject * obj0 = 0 ;
28425 PyObject * obj1 = 0 ;
28426 char * kwnames[] = {
28427 (char *) "win",(char *) "onlyIfNeeded", NULL
28428 };
28429
28430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28431 if (obj0) {
28432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28433 if (!SWIG_IsOK(res1)) {
28434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28435 }
28436 arg1 = reinterpret_cast< wxWindow * >(argp1);
28437 }
28438 if (obj1) {
28439 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28440 if (!SWIG_IsOK(ecode2)) {
28441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28442 }
28443 arg2 = static_cast< bool >(val2);
28444 }
28445 {
28446 PyThreadState* __tstate = wxPyBeginAllowThreads();
28447 result = (bool)wxSafeYield(arg1,arg2);
28448 wxPyEndAllowThreads(__tstate);
28449 if (PyErr_Occurred()) SWIG_fail;
28450 }
28451 {
28452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28453 }
28454 return resultobj;
28455 fail:
28456 return NULL;
28457 }
28458
28459
28460 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28461 PyObject *resultobj = 0;
28462
28463 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28464 {
28465 PyThreadState* __tstate = wxPyBeginAllowThreads();
28466 wxWakeUpIdle();
28467 wxPyEndAllowThreads(__tstate);
28468 if (PyErr_Occurred()) SWIG_fail;
28469 }
28470 resultobj = SWIG_Py_Void();
28471 return resultobj;
28472 fail:
28473 return NULL;
28474 }
28475
28476
28477 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28478 PyObject *resultobj = 0;
28479 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28480 wxEvent *arg2 = 0 ;
28481 void *argp1 = 0 ;
28482 int res1 = 0 ;
28483 void *argp2 = 0 ;
28484 int res2 = 0 ;
28485 PyObject * obj0 = 0 ;
28486 PyObject * obj1 = 0 ;
28487 char * kwnames[] = {
28488 (char *) "dest",(char *) "event", NULL
28489 };
28490
28491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28493 if (!SWIG_IsOK(res1)) {
28494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28495 }
28496 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28497 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28498 if (!SWIG_IsOK(res2)) {
28499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28500 }
28501 if (!argp2) {
28502 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28503 }
28504 arg2 = reinterpret_cast< wxEvent * >(argp2);
28505 {
28506 PyThreadState* __tstate = wxPyBeginAllowThreads();
28507 wxPostEvent(arg1,*arg2);
28508 wxPyEndAllowThreads(__tstate);
28509 if (PyErr_Occurred()) SWIG_fail;
28510 }
28511 resultobj = SWIG_Py_Void();
28512 return resultobj;
28513 fail:
28514 return NULL;
28515 }
28516
28517
28518 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28519 PyObject *resultobj = 0;
28520
28521 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28522 {
28523 PyThreadState* __tstate = wxPyBeginAllowThreads();
28524 wxApp_CleanUp();
28525 wxPyEndAllowThreads(__tstate);
28526 if (PyErr_Occurred()) SWIG_fail;
28527 }
28528 resultobj = SWIG_Py_Void();
28529 return resultobj;
28530 fail:
28531 return NULL;
28532 }
28533
28534
28535 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28536 PyObject *resultobj = 0;
28537 wxPyApp *result = 0 ;
28538
28539 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28540 {
28541 PyThreadState* __tstate = wxPyBeginAllowThreads();
28542 result = (wxPyApp *)wxPyGetApp();
28543 wxPyEndAllowThreads(__tstate);
28544 if (PyErr_Occurred()) SWIG_fail;
28545 }
28546 {
28547 resultobj = wxPyMake_wxObject(result, 0);
28548 }
28549 return resultobj;
28550 fail:
28551 return NULL;
28552 }
28553
28554
28555 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28556 PyObject *resultobj = 0;
28557 char *arg1 = (char *) 0 ;
28558 int res1 ;
28559 char *buf1 = 0 ;
28560 int alloc1 = 0 ;
28561 PyObject * obj0 = 0 ;
28562 char * kwnames[] = {
28563 (char *) "encoding", NULL
28564 };
28565
28566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28567 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28568 if (!SWIG_IsOK(res1)) {
28569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28570 }
28571 arg1 = buf1;
28572 {
28573 PyThreadState* __tstate = wxPyBeginAllowThreads();
28574 wxSetDefaultPyEncoding((char const *)arg1);
28575 wxPyEndAllowThreads(__tstate);
28576 if (PyErr_Occurred()) SWIG_fail;
28577 }
28578 resultobj = SWIG_Py_Void();
28579 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28580 return resultobj;
28581 fail:
28582 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28583 return NULL;
28584 }
28585
28586
28587 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28588 PyObject *resultobj = 0;
28589 char *result = 0 ;
28590
28591 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28592 {
28593 PyThreadState* __tstate = wxPyBeginAllowThreads();
28594 result = (char *)wxGetDefaultPyEncoding();
28595 wxPyEndAllowThreads(__tstate);
28596 if (PyErr_Occurred()) SWIG_fail;
28597 }
28598 resultobj = SWIG_FromCharPtr(result);
28599 return resultobj;
28600 fail:
28601 return NULL;
28602 }
28603
28604
28605 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28606 PyObject *resultobj = 0;
28607 wxEventLoop *result = 0 ;
28608
28609 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28610 {
28611 PyThreadState* __tstate = wxPyBeginAllowThreads();
28612 result = (wxEventLoop *)new wxEventLoop();
28613 wxPyEndAllowThreads(__tstate);
28614 if (PyErr_Occurred()) SWIG_fail;
28615 }
28616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28617 return resultobj;
28618 fail:
28619 return NULL;
28620 }
28621
28622
28623 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28624 PyObject *resultobj = 0;
28625 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28626 void *argp1 = 0 ;
28627 int res1 = 0 ;
28628 PyObject *swig_obj[1] ;
28629
28630 if (!args) SWIG_fail;
28631 swig_obj[0] = args;
28632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28633 if (!SWIG_IsOK(res1)) {
28634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28635 }
28636 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28637 {
28638 PyThreadState* __tstate = wxPyBeginAllowThreads();
28639 delete arg1;
28640
28641 wxPyEndAllowThreads(__tstate);
28642 if (PyErr_Occurred()) SWIG_fail;
28643 }
28644 resultobj = SWIG_Py_Void();
28645 return resultobj;
28646 fail:
28647 return NULL;
28648 }
28649
28650
28651 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28652 PyObject *resultobj = 0;
28653 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28654 int result;
28655 void *argp1 = 0 ;
28656 int res1 = 0 ;
28657 PyObject *swig_obj[1] ;
28658
28659 if (!args) SWIG_fail;
28660 swig_obj[0] = args;
28661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28662 if (!SWIG_IsOK(res1)) {
28663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28664 }
28665 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28666 {
28667 PyThreadState* __tstate = wxPyBeginAllowThreads();
28668 result = (int)(arg1)->Run();
28669 wxPyEndAllowThreads(__tstate);
28670 if (PyErr_Occurred()) SWIG_fail;
28671 }
28672 resultobj = SWIG_From_int(static_cast< int >(result));
28673 return resultobj;
28674 fail:
28675 return NULL;
28676 }
28677
28678
28679 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28680 PyObject *resultobj = 0;
28681 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28682 int arg2 = (int) 0 ;
28683 void *argp1 = 0 ;
28684 int res1 = 0 ;
28685 int val2 ;
28686 int ecode2 = 0 ;
28687 PyObject * obj0 = 0 ;
28688 PyObject * obj1 = 0 ;
28689 char * kwnames[] = {
28690 (char *) "self",(char *) "rc", NULL
28691 };
28692
28693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28695 if (!SWIG_IsOK(res1)) {
28696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28697 }
28698 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28699 if (obj1) {
28700 ecode2 = SWIG_AsVal_int(obj1, &val2);
28701 if (!SWIG_IsOK(ecode2)) {
28702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28703 }
28704 arg2 = static_cast< int >(val2);
28705 }
28706 {
28707 PyThreadState* __tstate = wxPyBeginAllowThreads();
28708 (arg1)->Exit(arg2);
28709 wxPyEndAllowThreads(__tstate);
28710 if (PyErr_Occurred()) SWIG_fail;
28711 }
28712 resultobj = SWIG_Py_Void();
28713 return resultobj;
28714 fail:
28715 return NULL;
28716 }
28717
28718
28719 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28720 PyObject *resultobj = 0;
28721 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28722 bool result;
28723 void *argp1 = 0 ;
28724 int res1 = 0 ;
28725 PyObject *swig_obj[1] ;
28726
28727 if (!args) SWIG_fail;
28728 swig_obj[0] = args;
28729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28730 if (!SWIG_IsOK(res1)) {
28731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28732 }
28733 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28734 {
28735 PyThreadState* __tstate = wxPyBeginAllowThreads();
28736 result = (bool)((wxEventLoop const *)arg1)->Pending();
28737 wxPyEndAllowThreads(__tstate);
28738 if (PyErr_Occurred()) SWIG_fail;
28739 }
28740 {
28741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28742 }
28743 return resultobj;
28744 fail:
28745 return NULL;
28746 }
28747
28748
28749 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28750 PyObject *resultobj = 0;
28751 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28752 bool result;
28753 void *argp1 = 0 ;
28754 int res1 = 0 ;
28755 PyObject *swig_obj[1] ;
28756
28757 if (!args) SWIG_fail;
28758 swig_obj[0] = args;
28759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28760 if (!SWIG_IsOK(res1)) {
28761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28762 }
28763 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28764 {
28765 PyThreadState* __tstate = wxPyBeginAllowThreads();
28766 result = (bool)(arg1)->Dispatch();
28767 wxPyEndAllowThreads(__tstate);
28768 if (PyErr_Occurred()) SWIG_fail;
28769 }
28770 {
28771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28772 }
28773 return resultobj;
28774 fail:
28775 return NULL;
28776 }
28777
28778
28779 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28780 PyObject *resultobj = 0;
28781 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28782 bool result;
28783 void *argp1 = 0 ;
28784 int res1 = 0 ;
28785 PyObject *swig_obj[1] ;
28786
28787 if (!args) SWIG_fail;
28788 swig_obj[0] = args;
28789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28790 if (!SWIG_IsOK(res1)) {
28791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28792 }
28793 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28794 {
28795 PyThreadState* __tstate = wxPyBeginAllowThreads();
28796 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28797 wxPyEndAllowThreads(__tstate);
28798 if (PyErr_Occurred()) SWIG_fail;
28799 }
28800 {
28801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28802 }
28803 return resultobj;
28804 fail:
28805 return NULL;
28806 }
28807
28808
28809 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28810 PyObject *resultobj = 0;
28811 wxEventLoop *result = 0 ;
28812
28813 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28814 {
28815 PyThreadState* __tstate = wxPyBeginAllowThreads();
28816 result = (wxEventLoop *)wxEventLoop::GetActive();
28817 wxPyEndAllowThreads(__tstate);
28818 if (PyErr_Occurred()) SWIG_fail;
28819 }
28820 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28821 return resultobj;
28822 fail:
28823 return NULL;
28824 }
28825
28826
28827 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28828 PyObject *resultobj = 0;
28829 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28830 void *argp1 = 0 ;
28831 int res1 = 0 ;
28832 PyObject * obj0 = 0 ;
28833 char * kwnames[] = {
28834 (char *) "loop", NULL
28835 };
28836
28837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28839 if (!SWIG_IsOK(res1)) {
28840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28841 }
28842 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28843 {
28844 PyThreadState* __tstate = wxPyBeginAllowThreads();
28845 wxEventLoop::SetActive(arg1);
28846 wxPyEndAllowThreads(__tstate);
28847 if (PyErr_Occurred()) SWIG_fail;
28848 }
28849 resultobj = SWIG_Py_Void();
28850 return resultobj;
28851 fail:
28852 return NULL;
28853 }
28854
28855
28856 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28857 PyObject *obj;
28858 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28859 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28860 return SWIG_Py_Void();
28861 }
28862
28863 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28864 return SWIG_Python_InitShadowInstance(args);
28865 }
28866
28867 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28868 PyObject *resultobj = 0;
28869 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28870 wxEventLoopActivator *result = 0 ;
28871 void *argp1 = 0 ;
28872 int res1 = 0 ;
28873 PyObject * obj0 = 0 ;
28874 char * kwnames[] = {
28875 (char *) "evtLoop", NULL
28876 };
28877
28878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28880 if (!SWIG_IsOK(res1)) {
28881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28882 }
28883 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28884 {
28885 PyThreadState* __tstate = wxPyBeginAllowThreads();
28886 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28887 wxPyEndAllowThreads(__tstate);
28888 if (PyErr_Occurred()) SWIG_fail;
28889 }
28890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28891 return resultobj;
28892 fail:
28893 return NULL;
28894 }
28895
28896
28897 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28898 PyObject *resultobj = 0;
28899 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28900 void *argp1 = 0 ;
28901 int res1 = 0 ;
28902 PyObject *swig_obj[1] ;
28903
28904 if (!args) SWIG_fail;
28905 swig_obj[0] = args;
28906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28907 if (!SWIG_IsOK(res1)) {
28908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28909 }
28910 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28911 {
28912 PyThreadState* __tstate = wxPyBeginAllowThreads();
28913 delete arg1;
28914
28915 wxPyEndAllowThreads(__tstate);
28916 if (PyErr_Occurred()) SWIG_fail;
28917 }
28918 resultobj = SWIG_Py_Void();
28919 return resultobj;
28920 fail:
28921 return NULL;
28922 }
28923
28924
28925 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28926 PyObject *obj;
28927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28928 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28929 return SWIG_Py_Void();
28930 }
28931
28932 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28933 return SWIG_Python_InitShadowInstance(args);
28934 }
28935
28936 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28937 PyObject *resultobj = 0;
28938 int arg1 = (int) 0 ;
28939 int arg2 = (int) 0 ;
28940 int arg3 = (int) 0 ;
28941 wxAcceleratorEntry *result = 0 ;
28942 int val1 ;
28943 int ecode1 = 0 ;
28944 int val2 ;
28945 int ecode2 = 0 ;
28946 int val3 ;
28947 int ecode3 = 0 ;
28948 PyObject * obj0 = 0 ;
28949 PyObject * obj1 = 0 ;
28950 PyObject * obj2 = 0 ;
28951 char * kwnames[] = {
28952 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28953 };
28954
28955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28956 if (obj0) {
28957 ecode1 = SWIG_AsVal_int(obj0, &val1);
28958 if (!SWIG_IsOK(ecode1)) {
28959 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28960 }
28961 arg1 = static_cast< int >(val1);
28962 }
28963 if (obj1) {
28964 ecode2 = SWIG_AsVal_int(obj1, &val2);
28965 if (!SWIG_IsOK(ecode2)) {
28966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28967 }
28968 arg2 = static_cast< int >(val2);
28969 }
28970 if (obj2) {
28971 ecode3 = SWIG_AsVal_int(obj2, &val3);
28972 if (!SWIG_IsOK(ecode3)) {
28973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28974 }
28975 arg3 = static_cast< int >(val3);
28976 }
28977 {
28978 PyThreadState* __tstate = wxPyBeginAllowThreads();
28979 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28980 wxPyEndAllowThreads(__tstate);
28981 if (PyErr_Occurred()) SWIG_fail;
28982 }
28983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28984 return resultobj;
28985 fail:
28986 return NULL;
28987 }
28988
28989
28990 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28991 PyObject *resultobj = 0;
28992 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28993 void *argp1 = 0 ;
28994 int res1 = 0 ;
28995 PyObject *swig_obj[1] ;
28996
28997 if (!args) SWIG_fail;
28998 swig_obj[0] = args;
28999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29000 if (!SWIG_IsOK(res1)) {
29001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29002 }
29003 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29004 {
29005 PyThreadState* __tstate = wxPyBeginAllowThreads();
29006 delete arg1;
29007
29008 wxPyEndAllowThreads(__tstate);
29009 if (PyErr_Occurred()) SWIG_fail;
29010 }
29011 resultobj = SWIG_Py_Void();
29012 return resultobj;
29013 fail:
29014 return NULL;
29015 }
29016
29017
29018 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29019 PyObject *resultobj = 0;
29020 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29021 int arg2 ;
29022 int arg3 ;
29023 int arg4 ;
29024 void *argp1 = 0 ;
29025 int res1 = 0 ;
29026 int val2 ;
29027 int ecode2 = 0 ;
29028 int val3 ;
29029 int ecode3 = 0 ;
29030 int val4 ;
29031 int ecode4 = 0 ;
29032 PyObject * obj0 = 0 ;
29033 PyObject * obj1 = 0 ;
29034 PyObject * obj2 = 0 ;
29035 PyObject * obj3 = 0 ;
29036 char * kwnames[] = {
29037 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29038 };
29039
29040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29042 if (!SWIG_IsOK(res1)) {
29043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29044 }
29045 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29046 ecode2 = SWIG_AsVal_int(obj1, &val2);
29047 if (!SWIG_IsOK(ecode2)) {
29048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29049 }
29050 arg2 = static_cast< int >(val2);
29051 ecode3 = SWIG_AsVal_int(obj2, &val3);
29052 if (!SWIG_IsOK(ecode3)) {
29053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29054 }
29055 arg3 = static_cast< int >(val3);
29056 ecode4 = SWIG_AsVal_int(obj3, &val4);
29057 if (!SWIG_IsOK(ecode4)) {
29058 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29059 }
29060 arg4 = static_cast< int >(val4);
29061 {
29062 PyThreadState* __tstate = wxPyBeginAllowThreads();
29063 (arg1)->Set(arg2,arg3,arg4);
29064 wxPyEndAllowThreads(__tstate);
29065 if (PyErr_Occurred()) SWIG_fail;
29066 }
29067 resultobj = SWIG_Py_Void();
29068 return resultobj;
29069 fail:
29070 return NULL;
29071 }
29072
29073
29074 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29075 PyObject *resultobj = 0;
29076 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29077 int result;
29078 void *argp1 = 0 ;
29079 int res1 = 0 ;
29080 PyObject *swig_obj[1] ;
29081
29082 if (!args) SWIG_fail;
29083 swig_obj[0] = args;
29084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29085 if (!SWIG_IsOK(res1)) {
29086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29087 }
29088 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29089 {
29090 PyThreadState* __tstate = wxPyBeginAllowThreads();
29091 result = (int)(arg1)->GetFlags();
29092 wxPyEndAllowThreads(__tstate);
29093 if (PyErr_Occurred()) SWIG_fail;
29094 }
29095 resultobj = SWIG_From_int(static_cast< int >(result));
29096 return resultobj;
29097 fail:
29098 return NULL;
29099 }
29100
29101
29102 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29103 PyObject *resultobj = 0;
29104 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29105 int result;
29106 void *argp1 = 0 ;
29107 int res1 = 0 ;
29108 PyObject *swig_obj[1] ;
29109
29110 if (!args) SWIG_fail;
29111 swig_obj[0] = args;
29112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29113 if (!SWIG_IsOK(res1)) {
29114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29115 }
29116 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29117 {
29118 PyThreadState* __tstate = wxPyBeginAllowThreads();
29119 result = (int)(arg1)->GetKeyCode();
29120 wxPyEndAllowThreads(__tstate);
29121 if (PyErr_Occurred()) SWIG_fail;
29122 }
29123 resultobj = SWIG_From_int(static_cast< int >(result));
29124 return resultobj;
29125 fail:
29126 return NULL;
29127 }
29128
29129
29130 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29131 PyObject *resultobj = 0;
29132 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29133 int result;
29134 void *argp1 = 0 ;
29135 int res1 = 0 ;
29136 PyObject *swig_obj[1] ;
29137
29138 if (!args) SWIG_fail;
29139 swig_obj[0] = args;
29140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29141 if (!SWIG_IsOK(res1)) {
29142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29143 }
29144 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29145 {
29146 PyThreadState* __tstate = wxPyBeginAllowThreads();
29147 result = (int)(arg1)->GetCommand();
29148 wxPyEndAllowThreads(__tstate);
29149 if (PyErr_Occurred()) SWIG_fail;
29150 }
29151 resultobj = SWIG_From_int(static_cast< int >(result));
29152 return resultobj;
29153 fail:
29154 return NULL;
29155 }
29156
29157
29158 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29159 PyObject *obj;
29160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29161 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29162 return SWIG_Py_Void();
29163 }
29164
29165 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29166 return SWIG_Python_InitShadowInstance(args);
29167 }
29168
29169 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29170 PyObject *resultobj = 0;
29171 int arg1 ;
29172 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29173 wxAcceleratorTable *result = 0 ;
29174 PyObject * obj0 = 0 ;
29175 char * kwnames[] = {
29176 (char *) "n", NULL
29177 };
29178
29179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29180 {
29181 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29182 if (arg2) arg1 = PyList_Size(obj0);
29183 else arg1 = 0;
29184 }
29185 {
29186 PyThreadState* __tstate = wxPyBeginAllowThreads();
29187 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29188 wxPyEndAllowThreads(__tstate);
29189 if (PyErr_Occurred()) SWIG_fail;
29190 }
29191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29192 return resultobj;
29193 fail:
29194 return NULL;
29195 }
29196
29197
29198 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29199 PyObject *resultobj = 0;
29200 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29201 void *argp1 = 0 ;
29202 int res1 = 0 ;
29203 PyObject *swig_obj[1] ;
29204
29205 if (!args) SWIG_fail;
29206 swig_obj[0] = args;
29207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29208 if (!SWIG_IsOK(res1)) {
29209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29210 }
29211 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29212 {
29213 PyThreadState* __tstate = wxPyBeginAllowThreads();
29214 delete arg1;
29215
29216 wxPyEndAllowThreads(__tstate);
29217 if (PyErr_Occurred()) SWIG_fail;
29218 }
29219 resultobj = SWIG_Py_Void();
29220 return resultobj;
29221 fail:
29222 return NULL;
29223 }
29224
29225
29226 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29227 PyObject *resultobj = 0;
29228 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29229 bool result;
29230 void *argp1 = 0 ;
29231 int res1 = 0 ;
29232 PyObject *swig_obj[1] ;
29233
29234 if (!args) SWIG_fail;
29235 swig_obj[0] = args;
29236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29237 if (!SWIG_IsOK(res1)) {
29238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29239 }
29240 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29241 {
29242 PyThreadState* __tstate = wxPyBeginAllowThreads();
29243 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29244 wxPyEndAllowThreads(__tstate);
29245 if (PyErr_Occurred()) SWIG_fail;
29246 }
29247 {
29248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29249 }
29250 return resultobj;
29251 fail:
29252 return NULL;
29253 }
29254
29255
29256 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29257 PyObject *obj;
29258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29259 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29260 return SWIG_Py_Void();
29261 }
29262
29263 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29264 return SWIG_Python_InitShadowInstance(args);
29265 }
29266
29267 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29268 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29269 return 1;
29270 }
29271
29272
29273 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29274 PyObject *pyobj = 0;
29275
29276 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29277 return pyobj;
29278 }
29279
29280
29281 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29282 PyObject *resultobj = 0;
29283 wxString *arg1 = 0 ;
29284 wxAcceleratorEntry *result = 0 ;
29285 bool temp1 = false ;
29286 PyObject * obj0 = 0 ;
29287 char * kwnames[] = {
29288 (char *) "label", NULL
29289 };
29290
29291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29292 {
29293 arg1 = wxString_in_helper(obj0);
29294 if (arg1 == NULL) SWIG_fail;
29295 temp1 = true;
29296 }
29297 {
29298 PyThreadState* __tstate = wxPyBeginAllowThreads();
29299 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29300 wxPyEndAllowThreads(__tstate);
29301 if (PyErr_Occurred()) SWIG_fail;
29302 }
29303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29304 {
29305 if (temp1)
29306 delete arg1;
29307 }
29308 return resultobj;
29309 fail:
29310 {
29311 if (temp1)
29312 delete arg1;
29313 }
29314 return NULL;
29315 }
29316
29317
29318 SWIGINTERN int PanelNameStr_set(PyObject *) {
29319 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29320 return 1;
29321 }
29322
29323
29324 SWIGINTERN PyObject *PanelNameStr_get(void) {
29325 PyObject *pyobj = 0;
29326
29327 {
29328 #if wxUSE_UNICODE
29329 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29330 #else
29331 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29332 #endif
29333 }
29334 return pyobj;
29335 }
29336
29337
29338 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29339 PyObject *resultobj = 0;
29340 wxVisualAttributes *result = 0 ;
29341
29342 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29343 {
29344 PyThreadState* __tstate = wxPyBeginAllowThreads();
29345 result = (wxVisualAttributes *)new_wxVisualAttributes();
29346 wxPyEndAllowThreads(__tstate);
29347 if (PyErr_Occurred()) SWIG_fail;
29348 }
29349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29350 return resultobj;
29351 fail:
29352 return NULL;
29353 }
29354
29355
29356 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29357 PyObject *resultobj = 0;
29358 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29359 void *argp1 = 0 ;
29360 int res1 = 0 ;
29361 PyObject *swig_obj[1] ;
29362
29363 if (!args) SWIG_fail;
29364 swig_obj[0] = args;
29365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29366 if (!SWIG_IsOK(res1)) {
29367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29368 }
29369 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29370 {
29371 PyThreadState* __tstate = wxPyBeginAllowThreads();
29372 delete_wxVisualAttributes(arg1);
29373
29374 wxPyEndAllowThreads(__tstate);
29375 if (PyErr_Occurred()) SWIG_fail;
29376 }
29377 resultobj = SWIG_Py_Void();
29378 return resultobj;
29379 fail:
29380 return NULL;
29381 }
29382
29383
29384 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29385 PyObject *resultobj = 0;
29386 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29387 wxFont *arg2 = (wxFont *) 0 ;
29388 void *argp1 = 0 ;
29389 int res1 = 0 ;
29390 void *argp2 = 0 ;
29391 int res2 = 0 ;
29392 PyObject *swig_obj[2] ;
29393
29394 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29396 if (!SWIG_IsOK(res1)) {
29397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29398 }
29399 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29400 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29401 if (!SWIG_IsOK(res2)) {
29402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29403 }
29404 arg2 = reinterpret_cast< wxFont * >(argp2);
29405 if (arg1) (arg1)->font = *arg2;
29406
29407 resultobj = SWIG_Py_Void();
29408 return resultobj;
29409 fail:
29410 return NULL;
29411 }
29412
29413
29414 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29415 PyObject *resultobj = 0;
29416 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29417 wxFont *result = 0 ;
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_wxVisualAttributes, 0 | 0 );
29425 if (!SWIG_IsOK(res1)) {
29426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29427 }
29428 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29429 result = (wxFont *)& ((arg1)->font);
29430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29431 return resultobj;
29432 fail:
29433 return NULL;
29434 }
29435
29436
29437 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29438 PyObject *resultobj = 0;
29439 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29440 wxColour *arg2 = (wxColour *) 0 ;
29441 void *argp1 = 0 ;
29442 int res1 = 0 ;
29443 void *argp2 = 0 ;
29444 int res2 = 0 ;
29445 PyObject *swig_obj[2] ;
29446
29447 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29449 if (!SWIG_IsOK(res1)) {
29450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29451 }
29452 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29453 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29454 if (!SWIG_IsOK(res2)) {
29455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29456 }
29457 arg2 = reinterpret_cast< wxColour * >(argp2);
29458 if (arg1) (arg1)->colFg = *arg2;
29459
29460 resultobj = SWIG_Py_Void();
29461 return resultobj;
29462 fail:
29463 return NULL;
29464 }
29465
29466
29467 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29468 PyObject *resultobj = 0;
29469 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29470 wxColour *result = 0 ;
29471 void *argp1 = 0 ;
29472 int res1 = 0 ;
29473 PyObject *swig_obj[1] ;
29474
29475 if (!args) SWIG_fail;
29476 swig_obj[0] = args;
29477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29478 if (!SWIG_IsOK(res1)) {
29479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29480 }
29481 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29482 result = (wxColour *)& ((arg1)->colFg);
29483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29484 return resultobj;
29485 fail:
29486 return NULL;
29487 }
29488
29489
29490 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29491 PyObject *resultobj = 0;
29492 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29493 wxColour *arg2 = (wxColour *) 0 ;
29494 void *argp1 = 0 ;
29495 int res1 = 0 ;
29496 void *argp2 = 0 ;
29497 int res2 = 0 ;
29498 PyObject *swig_obj[2] ;
29499
29500 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29502 if (!SWIG_IsOK(res1)) {
29503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29504 }
29505 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29506 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29507 if (!SWIG_IsOK(res2)) {
29508 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29509 }
29510 arg2 = reinterpret_cast< wxColour * >(argp2);
29511 if (arg1) (arg1)->colBg = *arg2;
29512
29513 resultobj = SWIG_Py_Void();
29514 return resultobj;
29515 fail:
29516 return NULL;
29517 }
29518
29519
29520 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29521 PyObject *resultobj = 0;
29522 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29523 wxColour *result = 0 ;
29524 void *argp1 = 0 ;
29525 int res1 = 0 ;
29526 PyObject *swig_obj[1] ;
29527
29528 if (!args) SWIG_fail;
29529 swig_obj[0] = args;
29530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29531 if (!SWIG_IsOK(res1)) {
29532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29533 }
29534 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29535 result = (wxColour *)& ((arg1)->colBg);
29536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29537 return resultobj;
29538 fail:
29539 return NULL;
29540 }
29541
29542
29543 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29544 PyObject *obj;
29545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29546 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29547 return SWIG_Py_Void();
29548 }
29549
29550 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29551 return SWIG_Python_InitShadowInstance(args);
29552 }
29553
29554 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29555 PyObject *resultobj = 0;
29556 wxWindow *arg1 = (wxWindow *) 0 ;
29557 int arg2 = (int) (int)-1 ;
29558 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29559 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29560 wxSize const &arg4_defvalue = wxDefaultSize ;
29561 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29562 long arg5 = (long) 0 ;
29563 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29564 wxString *arg6 = (wxString *) &arg6_defvalue ;
29565 wxWindow *result = 0 ;
29566 void *argp1 = 0 ;
29567 int res1 = 0 ;
29568 int val2 ;
29569 int ecode2 = 0 ;
29570 wxPoint temp3 ;
29571 wxSize temp4 ;
29572 long val5 ;
29573 int ecode5 = 0 ;
29574 bool temp6 = false ;
29575 PyObject * obj0 = 0 ;
29576 PyObject * obj1 = 0 ;
29577 PyObject * obj2 = 0 ;
29578 PyObject * obj3 = 0 ;
29579 PyObject * obj4 = 0 ;
29580 PyObject * obj5 = 0 ;
29581 char * kwnames[] = {
29582 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29583 };
29584
29585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29587 if (!SWIG_IsOK(res1)) {
29588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29589 }
29590 arg1 = reinterpret_cast< wxWindow * >(argp1);
29591 if (obj1) {
29592 ecode2 = SWIG_AsVal_int(obj1, &val2);
29593 if (!SWIG_IsOK(ecode2)) {
29594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29595 }
29596 arg2 = static_cast< int >(val2);
29597 }
29598 if (obj2) {
29599 {
29600 arg3 = &temp3;
29601 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29602 }
29603 }
29604 if (obj3) {
29605 {
29606 arg4 = &temp4;
29607 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29608 }
29609 }
29610 if (obj4) {
29611 ecode5 = SWIG_AsVal_long(obj4, &val5);
29612 if (!SWIG_IsOK(ecode5)) {
29613 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29614 }
29615 arg5 = static_cast< long >(val5);
29616 }
29617 if (obj5) {
29618 {
29619 arg6 = wxString_in_helper(obj5);
29620 if (arg6 == NULL) SWIG_fail;
29621 temp6 = true;
29622 }
29623 }
29624 {
29625 if (!wxPyCheckForApp()) SWIG_fail;
29626 PyThreadState* __tstate = wxPyBeginAllowThreads();
29627 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29628 wxPyEndAllowThreads(__tstate);
29629 if (PyErr_Occurred()) SWIG_fail;
29630 }
29631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29632 {
29633 if (temp6)
29634 delete arg6;
29635 }
29636 return resultobj;
29637 fail:
29638 {
29639 if (temp6)
29640 delete arg6;
29641 }
29642 return NULL;
29643 }
29644
29645
29646 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29647 PyObject *resultobj = 0;
29648 wxWindow *result = 0 ;
29649
29650 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29651 {
29652 if (!wxPyCheckForApp()) SWIG_fail;
29653 PyThreadState* __tstate = wxPyBeginAllowThreads();
29654 result = (wxWindow *)new wxWindow();
29655 wxPyEndAllowThreads(__tstate);
29656 if (PyErr_Occurred()) SWIG_fail;
29657 }
29658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29659 return resultobj;
29660 fail:
29661 return NULL;
29662 }
29663
29664
29665 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29666 PyObject *resultobj = 0;
29667 wxWindow *arg1 = (wxWindow *) 0 ;
29668 wxWindow *arg2 = (wxWindow *) 0 ;
29669 int arg3 = (int) (int)-1 ;
29670 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29671 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29672 wxSize const &arg5_defvalue = wxDefaultSize ;
29673 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29674 long arg6 = (long) 0 ;
29675 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29676 wxString *arg7 = (wxString *) &arg7_defvalue ;
29677 bool result;
29678 void *argp1 = 0 ;
29679 int res1 = 0 ;
29680 void *argp2 = 0 ;
29681 int res2 = 0 ;
29682 int val3 ;
29683 int ecode3 = 0 ;
29684 wxPoint temp4 ;
29685 wxSize temp5 ;
29686 long val6 ;
29687 int ecode6 = 0 ;
29688 bool temp7 = false ;
29689 PyObject * obj0 = 0 ;
29690 PyObject * obj1 = 0 ;
29691 PyObject * obj2 = 0 ;
29692 PyObject * obj3 = 0 ;
29693 PyObject * obj4 = 0 ;
29694 PyObject * obj5 = 0 ;
29695 PyObject * obj6 = 0 ;
29696 char * kwnames[] = {
29697 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29698 };
29699
29700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29702 if (!SWIG_IsOK(res1)) {
29703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29704 }
29705 arg1 = reinterpret_cast< wxWindow * >(argp1);
29706 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29707 if (!SWIG_IsOK(res2)) {
29708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29709 }
29710 arg2 = reinterpret_cast< wxWindow * >(argp2);
29711 if (obj2) {
29712 ecode3 = SWIG_AsVal_int(obj2, &val3);
29713 if (!SWIG_IsOK(ecode3)) {
29714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29715 }
29716 arg3 = static_cast< int >(val3);
29717 }
29718 if (obj3) {
29719 {
29720 arg4 = &temp4;
29721 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29722 }
29723 }
29724 if (obj4) {
29725 {
29726 arg5 = &temp5;
29727 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29728 }
29729 }
29730 if (obj5) {
29731 ecode6 = SWIG_AsVal_long(obj5, &val6);
29732 if (!SWIG_IsOK(ecode6)) {
29733 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29734 }
29735 arg6 = static_cast< long >(val6);
29736 }
29737 if (obj6) {
29738 {
29739 arg7 = wxString_in_helper(obj6);
29740 if (arg7 == NULL) SWIG_fail;
29741 temp7 = true;
29742 }
29743 }
29744 {
29745 PyThreadState* __tstate = wxPyBeginAllowThreads();
29746 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29747 wxPyEndAllowThreads(__tstate);
29748 if (PyErr_Occurred()) SWIG_fail;
29749 }
29750 {
29751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29752 }
29753 {
29754 if (temp7)
29755 delete arg7;
29756 }
29757 return resultobj;
29758 fail:
29759 {
29760 if (temp7)
29761 delete arg7;
29762 }
29763 return NULL;
29764 }
29765
29766
29767 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29768 PyObject *resultobj = 0;
29769 wxWindow *arg1 = (wxWindow *) 0 ;
29770 bool arg2 = (bool) false ;
29771 bool result;
29772 void *argp1 = 0 ;
29773 int res1 = 0 ;
29774 bool val2 ;
29775 int ecode2 = 0 ;
29776 PyObject * obj0 = 0 ;
29777 PyObject * obj1 = 0 ;
29778 char * kwnames[] = {
29779 (char *) "self",(char *) "force", NULL
29780 };
29781
29782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29784 if (!SWIG_IsOK(res1)) {
29785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29786 }
29787 arg1 = reinterpret_cast< wxWindow * >(argp1);
29788 if (obj1) {
29789 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29790 if (!SWIG_IsOK(ecode2)) {
29791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29792 }
29793 arg2 = static_cast< bool >(val2);
29794 }
29795 {
29796 PyThreadState* __tstate = wxPyBeginAllowThreads();
29797 result = (bool)(arg1)->Close(arg2);
29798 wxPyEndAllowThreads(__tstate);
29799 if (PyErr_Occurred()) SWIG_fail;
29800 }
29801 {
29802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29803 }
29804 return resultobj;
29805 fail:
29806 return NULL;
29807 }
29808
29809
29810 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29811 PyObject *resultobj = 0;
29812 wxWindow *arg1 = (wxWindow *) 0 ;
29813 bool result;
29814 void *argp1 = 0 ;
29815 int res1 = 0 ;
29816 PyObject *swig_obj[1] ;
29817
29818 if (!args) SWIG_fail;
29819 swig_obj[0] = args;
29820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29821 if (!SWIG_IsOK(res1)) {
29822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29823 }
29824 arg1 = reinterpret_cast< wxWindow * >(argp1);
29825 {
29826 PyThreadState* __tstate = wxPyBeginAllowThreads();
29827 result = (bool)(arg1)->Destroy();
29828 wxPyEndAllowThreads(__tstate);
29829 if (PyErr_Occurred()) SWIG_fail;
29830 }
29831 {
29832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29833 }
29834 return resultobj;
29835 fail:
29836 return NULL;
29837 }
29838
29839
29840 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29841 PyObject *resultobj = 0;
29842 wxWindow *arg1 = (wxWindow *) 0 ;
29843 bool result;
29844 void *argp1 = 0 ;
29845 int res1 = 0 ;
29846 PyObject *swig_obj[1] ;
29847
29848 if (!args) SWIG_fail;
29849 swig_obj[0] = args;
29850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29851 if (!SWIG_IsOK(res1)) {
29852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29853 }
29854 arg1 = reinterpret_cast< wxWindow * >(argp1);
29855 {
29856 PyThreadState* __tstate = wxPyBeginAllowThreads();
29857 result = (bool)(arg1)->DestroyChildren();
29858 wxPyEndAllowThreads(__tstate);
29859 if (PyErr_Occurred()) SWIG_fail;
29860 }
29861 {
29862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29863 }
29864 return resultobj;
29865 fail:
29866 return NULL;
29867 }
29868
29869
29870 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29871 PyObject *resultobj = 0;
29872 wxWindow *arg1 = (wxWindow *) 0 ;
29873 bool result;
29874 void *argp1 = 0 ;
29875 int res1 = 0 ;
29876 PyObject *swig_obj[1] ;
29877
29878 if (!args) SWIG_fail;
29879 swig_obj[0] = args;
29880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29881 if (!SWIG_IsOK(res1)) {
29882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29883 }
29884 arg1 = reinterpret_cast< wxWindow * >(argp1);
29885 {
29886 PyThreadState* __tstate = wxPyBeginAllowThreads();
29887 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29888 wxPyEndAllowThreads(__tstate);
29889 if (PyErr_Occurred()) SWIG_fail;
29890 }
29891 {
29892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29893 }
29894 return resultobj;
29895 fail:
29896 return NULL;
29897 }
29898
29899
29900 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29901 PyObject *resultobj = 0;
29902 wxWindow *arg1 = (wxWindow *) 0 ;
29903 wxString *arg2 = 0 ;
29904 void *argp1 = 0 ;
29905 int res1 = 0 ;
29906 bool temp2 = false ;
29907 PyObject * obj0 = 0 ;
29908 PyObject * obj1 = 0 ;
29909 char * kwnames[] = {
29910 (char *) "self",(char *) "label", NULL
29911 };
29912
29913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29915 if (!SWIG_IsOK(res1)) {
29916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29917 }
29918 arg1 = reinterpret_cast< wxWindow * >(argp1);
29919 {
29920 arg2 = wxString_in_helper(obj1);
29921 if (arg2 == NULL) SWIG_fail;
29922 temp2 = true;
29923 }
29924 {
29925 PyThreadState* __tstate = wxPyBeginAllowThreads();
29926 (arg1)->SetLabel((wxString const &)*arg2);
29927 wxPyEndAllowThreads(__tstate);
29928 if (PyErr_Occurred()) SWIG_fail;
29929 }
29930 resultobj = SWIG_Py_Void();
29931 {
29932 if (temp2)
29933 delete arg2;
29934 }
29935 return resultobj;
29936 fail:
29937 {
29938 if (temp2)
29939 delete arg2;
29940 }
29941 return NULL;
29942 }
29943
29944
29945 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29946 PyObject *resultobj = 0;
29947 wxWindow *arg1 = (wxWindow *) 0 ;
29948 wxString result;
29949 void *argp1 = 0 ;
29950 int res1 = 0 ;
29951 PyObject *swig_obj[1] ;
29952
29953 if (!args) SWIG_fail;
29954 swig_obj[0] = args;
29955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29956 if (!SWIG_IsOK(res1)) {
29957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29958 }
29959 arg1 = reinterpret_cast< wxWindow * >(argp1);
29960 {
29961 PyThreadState* __tstate = wxPyBeginAllowThreads();
29962 result = ((wxWindow const *)arg1)->GetLabel();
29963 wxPyEndAllowThreads(__tstate);
29964 if (PyErr_Occurred()) SWIG_fail;
29965 }
29966 {
29967 #if wxUSE_UNICODE
29968 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29969 #else
29970 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29971 #endif
29972 }
29973 return resultobj;
29974 fail:
29975 return NULL;
29976 }
29977
29978
29979 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29980 PyObject *resultobj = 0;
29981 wxWindow *arg1 = (wxWindow *) 0 ;
29982 wxString *arg2 = 0 ;
29983 void *argp1 = 0 ;
29984 int res1 = 0 ;
29985 bool temp2 = false ;
29986 PyObject * obj0 = 0 ;
29987 PyObject * obj1 = 0 ;
29988 char * kwnames[] = {
29989 (char *) "self",(char *) "name", NULL
29990 };
29991
29992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29994 if (!SWIG_IsOK(res1)) {
29995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29996 }
29997 arg1 = reinterpret_cast< wxWindow * >(argp1);
29998 {
29999 arg2 = wxString_in_helper(obj1);
30000 if (arg2 == NULL) SWIG_fail;
30001 temp2 = true;
30002 }
30003 {
30004 PyThreadState* __tstate = wxPyBeginAllowThreads();
30005 (arg1)->SetName((wxString const &)*arg2);
30006 wxPyEndAllowThreads(__tstate);
30007 if (PyErr_Occurred()) SWIG_fail;
30008 }
30009 resultobj = SWIG_Py_Void();
30010 {
30011 if (temp2)
30012 delete arg2;
30013 }
30014 return resultobj;
30015 fail:
30016 {
30017 if (temp2)
30018 delete arg2;
30019 }
30020 return NULL;
30021 }
30022
30023
30024 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30025 PyObject *resultobj = 0;
30026 wxWindow *arg1 = (wxWindow *) 0 ;
30027 wxString result;
30028 void *argp1 = 0 ;
30029 int res1 = 0 ;
30030 PyObject *swig_obj[1] ;
30031
30032 if (!args) SWIG_fail;
30033 swig_obj[0] = args;
30034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30035 if (!SWIG_IsOK(res1)) {
30036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30037 }
30038 arg1 = reinterpret_cast< wxWindow * >(argp1);
30039 {
30040 PyThreadState* __tstate = wxPyBeginAllowThreads();
30041 result = ((wxWindow const *)arg1)->GetName();
30042 wxPyEndAllowThreads(__tstate);
30043 if (PyErr_Occurred()) SWIG_fail;
30044 }
30045 {
30046 #if wxUSE_UNICODE
30047 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30048 #else
30049 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30050 #endif
30051 }
30052 return resultobj;
30053 fail:
30054 return NULL;
30055 }
30056
30057
30058 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30059 PyObject *resultobj = 0;
30060 wxWindow *arg1 = (wxWindow *) 0 ;
30061 wxWindowVariant arg2 ;
30062 void *argp1 = 0 ;
30063 int res1 = 0 ;
30064 int val2 ;
30065 int ecode2 = 0 ;
30066 PyObject * obj0 = 0 ;
30067 PyObject * obj1 = 0 ;
30068 char * kwnames[] = {
30069 (char *) "self",(char *) "variant", NULL
30070 };
30071
30072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30074 if (!SWIG_IsOK(res1)) {
30075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30076 }
30077 arg1 = reinterpret_cast< wxWindow * >(argp1);
30078 ecode2 = SWIG_AsVal_int(obj1, &val2);
30079 if (!SWIG_IsOK(ecode2)) {
30080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30081 }
30082 arg2 = static_cast< wxWindowVariant >(val2);
30083 {
30084 PyThreadState* __tstate = wxPyBeginAllowThreads();
30085 (arg1)->SetWindowVariant(arg2);
30086 wxPyEndAllowThreads(__tstate);
30087 if (PyErr_Occurred()) SWIG_fail;
30088 }
30089 resultobj = SWIG_Py_Void();
30090 return resultobj;
30091 fail:
30092 return NULL;
30093 }
30094
30095
30096 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30097 PyObject *resultobj = 0;
30098 wxWindow *arg1 = (wxWindow *) 0 ;
30099 wxWindowVariant result;
30100 void *argp1 = 0 ;
30101 int res1 = 0 ;
30102 PyObject *swig_obj[1] ;
30103
30104 if (!args) SWIG_fail;
30105 swig_obj[0] = args;
30106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30107 if (!SWIG_IsOK(res1)) {
30108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30109 }
30110 arg1 = reinterpret_cast< wxWindow * >(argp1);
30111 {
30112 PyThreadState* __tstate = wxPyBeginAllowThreads();
30113 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30114 wxPyEndAllowThreads(__tstate);
30115 if (PyErr_Occurred()) SWIG_fail;
30116 }
30117 resultobj = SWIG_From_int(static_cast< int >(result));
30118 return resultobj;
30119 fail:
30120 return NULL;
30121 }
30122
30123
30124 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30125 PyObject *resultobj = 0;
30126 wxWindow *arg1 = (wxWindow *) 0 ;
30127 int arg2 ;
30128 void *argp1 = 0 ;
30129 int res1 = 0 ;
30130 int val2 ;
30131 int ecode2 = 0 ;
30132 PyObject * obj0 = 0 ;
30133 PyObject * obj1 = 0 ;
30134 char * kwnames[] = {
30135 (char *) "self",(char *) "winid", NULL
30136 };
30137
30138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30140 if (!SWIG_IsOK(res1)) {
30141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30142 }
30143 arg1 = reinterpret_cast< wxWindow * >(argp1);
30144 ecode2 = SWIG_AsVal_int(obj1, &val2);
30145 if (!SWIG_IsOK(ecode2)) {
30146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30147 }
30148 arg2 = static_cast< int >(val2);
30149 {
30150 PyThreadState* __tstate = wxPyBeginAllowThreads();
30151 (arg1)->SetId(arg2);
30152 wxPyEndAllowThreads(__tstate);
30153 if (PyErr_Occurred()) SWIG_fail;
30154 }
30155 resultobj = SWIG_Py_Void();
30156 return resultobj;
30157 fail:
30158 return NULL;
30159 }
30160
30161
30162 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30163 PyObject *resultobj = 0;
30164 wxWindow *arg1 = (wxWindow *) 0 ;
30165 int result;
30166 void *argp1 = 0 ;
30167 int res1 = 0 ;
30168 PyObject *swig_obj[1] ;
30169
30170 if (!args) SWIG_fail;
30171 swig_obj[0] = args;
30172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30173 if (!SWIG_IsOK(res1)) {
30174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30175 }
30176 arg1 = reinterpret_cast< wxWindow * >(argp1);
30177 {
30178 PyThreadState* __tstate = wxPyBeginAllowThreads();
30179 result = (int)((wxWindow const *)arg1)->GetId();
30180 wxPyEndAllowThreads(__tstate);
30181 if (PyErr_Occurred()) SWIG_fail;
30182 }
30183 resultobj = SWIG_From_int(static_cast< int >(result));
30184 return resultobj;
30185 fail:
30186 return NULL;
30187 }
30188
30189
30190 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30191 PyObject *resultobj = 0;
30192 int result;
30193
30194 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30195 {
30196 PyThreadState* __tstate = wxPyBeginAllowThreads();
30197 result = (int)wxWindow::NewControlId();
30198 wxPyEndAllowThreads(__tstate);
30199 if (PyErr_Occurred()) SWIG_fail;
30200 }
30201 resultobj = SWIG_From_int(static_cast< int >(result));
30202 return resultobj;
30203 fail:
30204 return NULL;
30205 }
30206
30207
30208 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30209 PyObject *resultobj = 0;
30210 int arg1 ;
30211 int result;
30212 int val1 ;
30213 int ecode1 = 0 ;
30214 PyObject * obj0 = 0 ;
30215 char * kwnames[] = {
30216 (char *) "winid", NULL
30217 };
30218
30219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30220 ecode1 = SWIG_AsVal_int(obj0, &val1);
30221 if (!SWIG_IsOK(ecode1)) {
30222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30223 }
30224 arg1 = static_cast< int >(val1);
30225 {
30226 PyThreadState* __tstate = wxPyBeginAllowThreads();
30227 result = (int)wxWindow::NextControlId(arg1);
30228 wxPyEndAllowThreads(__tstate);
30229 if (PyErr_Occurred()) SWIG_fail;
30230 }
30231 resultobj = SWIG_From_int(static_cast< int >(result));
30232 return resultobj;
30233 fail:
30234 return NULL;
30235 }
30236
30237
30238 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30239 PyObject *resultobj = 0;
30240 int arg1 ;
30241 int result;
30242 int val1 ;
30243 int ecode1 = 0 ;
30244 PyObject * obj0 = 0 ;
30245 char * kwnames[] = {
30246 (char *) "winid", NULL
30247 };
30248
30249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30250 ecode1 = SWIG_AsVal_int(obj0, &val1);
30251 if (!SWIG_IsOK(ecode1)) {
30252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30253 }
30254 arg1 = static_cast< int >(val1);
30255 {
30256 PyThreadState* __tstate = wxPyBeginAllowThreads();
30257 result = (int)wxWindow::PrevControlId(arg1);
30258 wxPyEndAllowThreads(__tstate);
30259 if (PyErr_Occurred()) SWIG_fail;
30260 }
30261 resultobj = SWIG_From_int(static_cast< int >(result));
30262 return resultobj;
30263 fail:
30264 return NULL;
30265 }
30266
30267
30268 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30269 PyObject *resultobj = 0;
30270 wxWindow *arg1 = (wxWindow *) 0 ;
30271 wxSize *arg2 = 0 ;
30272 void *argp1 = 0 ;
30273 int res1 = 0 ;
30274 wxSize temp2 ;
30275 PyObject * obj0 = 0 ;
30276 PyObject * obj1 = 0 ;
30277 char * kwnames[] = {
30278 (char *) "self",(char *) "size", NULL
30279 };
30280
30281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30283 if (!SWIG_IsOK(res1)) {
30284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30285 }
30286 arg1 = reinterpret_cast< wxWindow * >(argp1);
30287 {
30288 arg2 = &temp2;
30289 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30290 }
30291 {
30292 PyThreadState* __tstate = wxPyBeginAllowThreads();
30293 (arg1)->SetSize((wxSize const &)*arg2);
30294 wxPyEndAllowThreads(__tstate);
30295 if (PyErr_Occurred()) SWIG_fail;
30296 }
30297 resultobj = SWIG_Py_Void();
30298 return resultobj;
30299 fail:
30300 return NULL;
30301 }
30302
30303
30304 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30305 PyObject *resultobj = 0;
30306 wxWindow *arg1 = (wxWindow *) 0 ;
30307 int arg2 ;
30308 int arg3 ;
30309 int arg4 ;
30310 int arg5 ;
30311 int arg6 = (int) wxSIZE_AUTO ;
30312 void *argp1 = 0 ;
30313 int res1 = 0 ;
30314 int val2 ;
30315 int ecode2 = 0 ;
30316 int val3 ;
30317 int ecode3 = 0 ;
30318 int val4 ;
30319 int ecode4 = 0 ;
30320 int val5 ;
30321 int ecode5 = 0 ;
30322 int val6 ;
30323 int ecode6 = 0 ;
30324 PyObject * obj0 = 0 ;
30325 PyObject * obj1 = 0 ;
30326 PyObject * obj2 = 0 ;
30327 PyObject * obj3 = 0 ;
30328 PyObject * obj4 = 0 ;
30329 PyObject * obj5 = 0 ;
30330 char * kwnames[] = {
30331 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30332 };
30333
30334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30336 if (!SWIG_IsOK(res1)) {
30337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30338 }
30339 arg1 = reinterpret_cast< wxWindow * >(argp1);
30340 ecode2 = SWIG_AsVal_int(obj1, &val2);
30341 if (!SWIG_IsOK(ecode2)) {
30342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30343 }
30344 arg2 = static_cast< int >(val2);
30345 ecode3 = SWIG_AsVal_int(obj2, &val3);
30346 if (!SWIG_IsOK(ecode3)) {
30347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30348 }
30349 arg3 = static_cast< int >(val3);
30350 ecode4 = SWIG_AsVal_int(obj3, &val4);
30351 if (!SWIG_IsOK(ecode4)) {
30352 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30353 }
30354 arg4 = static_cast< int >(val4);
30355 ecode5 = SWIG_AsVal_int(obj4, &val5);
30356 if (!SWIG_IsOK(ecode5)) {
30357 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30358 }
30359 arg5 = static_cast< int >(val5);
30360 if (obj5) {
30361 ecode6 = SWIG_AsVal_int(obj5, &val6);
30362 if (!SWIG_IsOK(ecode6)) {
30363 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30364 }
30365 arg6 = static_cast< int >(val6);
30366 }
30367 {
30368 PyThreadState* __tstate = wxPyBeginAllowThreads();
30369 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30370 wxPyEndAllowThreads(__tstate);
30371 if (PyErr_Occurred()) SWIG_fail;
30372 }
30373 resultobj = SWIG_Py_Void();
30374 return resultobj;
30375 fail:
30376 return NULL;
30377 }
30378
30379
30380 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30381 PyObject *resultobj = 0;
30382 wxWindow *arg1 = (wxWindow *) 0 ;
30383 wxRect *arg2 = 0 ;
30384 int arg3 = (int) wxSIZE_AUTO ;
30385 void *argp1 = 0 ;
30386 int res1 = 0 ;
30387 wxRect temp2 ;
30388 int val3 ;
30389 int ecode3 = 0 ;
30390 PyObject * obj0 = 0 ;
30391 PyObject * obj1 = 0 ;
30392 PyObject * obj2 = 0 ;
30393 char * kwnames[] = {
30394 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30395 };
30396
30397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30399 if (!SWIG_IsOK(res1)) {
30400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30401 }
30402 arg1 = reinterpret_cast< wxWindow * >(argp1);
30403 {
30404 arg2 = &temp2;
30405 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30406 }
30407 if (obj2) {
30408 ecode3 = SWIG_AsVal_int(obj2, &val3);
30409 if (!SWIG_IsOK(ecode3)) {
30410 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30411 }
30412 arg3 = static_cast< int >(val3);
30413 }
30414 {
30415 PyThreadState* __tstate = wxPyBeginAllowThreads();
30416 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30417 wxPyEndAllowThreads(__tstate);
30418 if (PyErr_Occurred()) SWIG_fail;
30419 }
30420 resultobj = SWIG_Py_Void();
30421 return resultobj;
30422 fail:
30423 return NULL;
30424 }
30425
30426
30427 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30428 PyObject *resultobj = 0;
30429 wxWindow *arg1 = (wxWindow *) 0 ;
30430 int arg2 ;
30431 int arg3 ;
30432 void *argp1 = 0 ;
30433 int res1 = 0 ;
30434 int val2 ;
30435 int ecode2 = 0 ;
30436 int val3 ;
30437 int ecode3 = 0 ;
30438 PyObject * obj0 = 0 ;
30439 PyObject * obj1 = 0 ;
30440 PyObject * obj2 = 0 ;
30441 char * kwnames[] = {
30442 (char *) "self",(char *) "width",(char *) "height", NULL
30443 };
30444
30445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30447 if (!SWIG_IsOK(res1)) {
30448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30449 }
30450 arg1 = reinterpret_cast< wxWindow * >(argp1);
30451 ecode2 = SWIG_AsVal_int(obj1, &val2);
30452 if (!SWIG_IsOK(ecode2)) {
30453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30454 }
30455 arg2 = static_cast< int >(val2);
30456 ecode3 = SWIG_AsVal_int(obj2, &val3);
30457 if (!SWIG_IsOK(ecode3)) {
30458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30459 }
30460 arg3 = static_cast< int >(val3);
30461 {
30462 PyThreadState* __tstate = wxPyBeginAllowThreads();
30463 (arg1)->SetSize(arg2,arg3);
30464 wxPyEndAllowThreads(__tstate);
30465 if (PyErr_Occurred()) SWIG_fail;
30466 }
30467 resultobj = SWIG_Py_Void();
30468 return resultobj;
30469 fail:
30470 return NULL;
30471 }
30472
30473
30474 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30475 PyObject *resultobj = 0;
30476 wxWindow *arg1 = (wxWindow *) 0 ;
30477 wxPoint *arg2 = 0 ;
30478 int arg3 = (int) wxSIZE_USE_EXISTING ;
30479 void *argp1 = 0 ;
30480 int res1 = 0 ;
30481 wxPoint temp2 ;
30482 int val3 ;
30483 int ecode3 = 0 ;
30484 PyObject * obj0 = 0 ;
30485 PyObject * obj1 = 0 ;
30486 PyObject * obj2 = 0 ;
30487 char * kwnames[] = {
30488 (char *) "self",(char *) "pt",(char *) "flags", NULL
30489 };
30490
30491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30493 if (!SWIG_IsOK(res1)) {
30494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30495 }
30496 arg1 = reinterpret_cast< wxWindow * >(argp1);
30497 {
30498 arg2 = &temp2;
30499 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30500 }
30501 if (obj2) {
30502 ecode3 = SWIG_AsVal_int(obj2, &val3);
30503 if (!SWIG_IsOK(ecode3)) {
30504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30505 }
30506 arg3 = static_cast< int >(val3);
30507 }
30508 {
30509 PyThreadState* __tstate = wxPyBeginAllowThreads();
30510 (arg1)->Move((wxPoint const &)*arg2,arg3);
30511 wxPyEndAllowThreads(__tstate);
30512 if (PyErr_Occurred()) SWIG_fail;
30513 }
30514 resultobj = SWIG_Py_Void();
30515 return resultobj;
30516 fail:
30517 return NULL;
30518 }
30519
30520
30521 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30522 PyObject *resultobj = 0;
30523 wxWindow *arg1 = (wxWindow *) 0 ;
30524 int arg2 ;
30525 int arg3 ;
30526 int arg4 = (int) wxSIZE_USE_EXISTING ;
30527 void *argp1 = 0 ;
30528 int res1 = 0 ;
30529 int val2 ;
30530 int ecode2 = 0 ;
30531 int val3 ;
30532 int ecode3 = 0 ;
30533 int val4 ;
30534 int ecode4 = 0 ;
30535 PyObject * obj0 = 0 ;
30536 PyObject * obj1 = 0 ;
30537 PyObject * obj2 = 0 ;
30538 PyObject * obj3 = 0 ;
30539 char * kwnames[] = {
30540 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30541 };
30542
30543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30545 if (!SWIG_IsOK(res1)) {
30546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30547 }
30548 arg1 = reinterpret_cast< wxWindow * >(argp1);
30549 ecode2 = SWIG_AsVal_int(obj1, &val2);
30550 if (!SWIG_IsOK(ecode2)) {
30551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30552 }
30553 arg2 = static_cast< int >(val2);
30554 ecode3 = SWIG_AsVal_int(obj2, &val3);
30555 if (!SWIG_IsOK(ecode3)) {
30556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30557 }
30558 arg3 = static_cast< int >(val3);
30559 if (obj3) {
30560 ecode4 = SWIG_AsVal_int(obj3, &val4);
30561 if (!SWIG_IsOK(ecode4)) {
30562 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30563 }
30564 arg4 = static_cast< int >(val4);
30565 }
30566 {
30567 PyThreadState* __tstate = wxPyBeginAllowThreads();
30568 (arg1)->Move(arg2,arg3,arg4);
30569 wxPyEndAllowThreads(__tstate);
30570 if (PyErr_Occurred()) SWIG_fail;
30571 }
30572 resultobj = SWIG_Py_Void();
30573 return resultobj;
30574 fail:
30575 return NULL;
30576 }
30577
30578
30579 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30580 PyObject *resultobj = 0;
30581 wxWindow *arg1 = (wxWindow *) 0 ;
30582 wxSize const &arg2_defvalue = wxDefaultSize ;
30583 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30584 void *argp1 = 0 ;
30585 int res1 = 0 ;
30586 wxSize temp2 ;
30587 PyObject * obj0 = 0 ;
30588 PyObject * obj1 = 0 ;
30589 char * kwnames[] = {
30590 (char *) "self",(char *) "size", NULL
30591 };
30592
30593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30595 if (!SWIG_IsOK(res1)) {
30596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30597 }
30598 arg1 = reinterpret_cast< wxWindow * >(argp1);
30599 if (obj1) {
30600 {
30601 arg2 = &temp2;
30602 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30603 }
30604 }
30605 {
30606 PyThreadState* __tstate = wxPyBeginAllowThreads();
30607 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30608 wxPyEndAllowThreads(__tstate);
30609 if (PyErr_Occurred()) SWIG_fail;
30610 }
30611 resultobj = SWIG_Py_Void();
30612 return resultobj;
30613 fail:
30614 return NULL;
30615 }
30616
30617
30618 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30619 PyObject *resultobj = 0;
30620 wxWindow *arg1 = (wxWindow *) 0 ;
30621 void *argp1 = 0 ;
30622 int res1 = 0 ;
30623 PyObject *swig_obj[1] ;
30624
30625 if (!args) SWIG_fail;
30626 swig_obj[0] = args;
30627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30628 if (!SWIG_IsOK(res1)) {
30629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30630 }
30631 arg1 = reinterpret_cast< wxWindow * >(argp1);
30632 {
30633 PyThreadState* __tstate = wxPyBeginAllowThreads();
30634 (arg1)->Raise();
30635 wxPyEndAllowThreads(__tstate);
30636 if (PyErr_Occurred()) SWIG_fail;
30637 }
30638 resultobj = SWIG_Py_Void();
30639 return resultobj;
30640 fail:
30641 return NULL;
30642 }
30643
30644
30645 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30646 PyObject *resultobj = 0;
30647 wxWindow *arg1 = (wxWindow *) 0 ;
30648 void *argp1 = 0 ;
30649 int res1 = 0 ;
30650 PyObject *swig_obj[1] ;
30651
30652 if (!args) SWIG_fail;
30653 swig_obj[0] = args;
30654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30655 if (!SWIG_IsOK(res1)) {
30656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30657 }
30658 arg1 = reinterpret_cast< wxWindow * >(argp1);
30659 {
30660 PyThreadState* __tstate = wxPyBeginAllowThreads();
30661 (arg1)->Lower();
30662 wxPyEndAllowThreads(__tstate);
30663 if (PyErr_Occurred()) SWIG_fail;
30664 }
30665 resultobj = SWIG_Py_Void();
30666 return resultobj;
30667 fail:
30668 return NULL;
30669 }
30670
30671
30672 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30673 PyObject *resultobj = 0;
30674 wxWindow *arg1 = (wxWindow *) 0 ;
30675 wxSize *arg2 = 0 ;
30676 void *argp1 = 0 ;
30677 int res1 = 0 ;
30678 wxSize temp2 ;
30679 PyObject * obj0 = 0 ;
30680 PyObject * obj1 = 0 ;
30681 char * kwnames[] = {
30682 (char *) "self",(char *) "size", NULL
30683 };
30684
30685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30687 if (!SWIG_IsOK(res1)) {
30688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30689 }
30690 arg1 = reinterpret_cast< wxWindow * >(argp1);
30691 {
30692 arg2 = &temp2;
30693 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30694 }
30695 {
30696 PyThreadState* __tstate = wxPyBeginAllowThreads();
30697 (arg1)->SetClientSize((wxSize const &)*arg2);
30698 wxPyEndAllowThreads(__tstate);
30699 if (PyErr_Occurred()) SWIG_fail;
30700 }
30701 resultobj = SWIG_Py_Void();
30702 return resultobj;
30703 fail:
30704 return NULL;
30705 }
30706
30707
30708 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30709 PyObject *resultobj = 0;
30710 wxWindow *arg1 = (wxWindow *) 0 ;
30711 int arg2 ;
30712 int arg3 ;
30713 void *argp1 = 0 ;
30714 int res1 = 0 ;
30715 int val2 ;
30716 int ecode2 = 0 ;
30717 int val3 ;
30718 int ecode3 = 0 ;
30719 PyObject * obj0 = 0 ;
30720 PyObject * obj1 = 0 ;
30721 PyObject * obj2 = 0 ;
30722 char * kwnames[] = {
30723 (char *) "self",(char *) "width",(char *) "height", NULL
30724 };
30725
30726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30728 if (!SWIG_IsOK(res1)) {
30729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30730 }
30731 arg1 = reinterpret_cast< wxWindow * >(argp1);
30732 ecode2 = SWIG_AsVal_int(obj1, &val2);
30733 if (!SWIG_IsOK(ecode2)) {
30734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30735 }
30736 arg2 = static_cast< int >(val2);
30737 ecode3 = SWIG_AsVal_int(obj2, &val3);
30738 if (!SWIG_IsOK(ecode3)) {
30739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30740 }
30741 arg3 = static_cast< int >(val3);
30742 {
30743 PyThreadState* __tstate = wxPyBeginAllowThreads();
30744 (arg1)->SetClientSize(arg2,arg3);
30745 wxPyEndAllowThreads(__tstate);
30746 if (PyErr_Occurred()) SWIG_fail;
30747 }
30748 resultobj = SWIG_Py_Void();
30749 return resultobj;
30750 fail:
30751 return NULL;
30752 }
30753
30754
30755 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30756 PyObject *resultobj = 0;
30757 wxWindow *arg1 = (wxWindow *) 0 ;
30758 wxRect *arg2 = 0 ;
30759 void *argp1 = 0 ;
30760 int res1 = 0 ;
30761 wxRect temp2 ;
30762 PyObject * obj0 = 0 ;
30763 PyObject * obj1 = 0 ;
30764 char * kwnames[] = {
30765 (char *) "self",(char *) "rect", NULL
30766 };
30767
30768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30770 if (!SWIG_IsOK(res1)) {
30771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30772 }
30773 arg1 = reinterpret_cast< wxWindow * >(argp1);
30774 {
30775 arg2 = &temp2;
30776 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30777 }
30778 {
30779 PyThreadState* __tstate = wxPyBeginAllowThreads();
30780 (arg1)->SetClientSize((wxRect const &)*arg2);
30781 wxPyEndAllowThreads(__tstate);
30782 if (PyErr_Occurred()) SWIG_fail;
30783 }
30784 resultobj = SWIG_Py_Void();
30785 return resultobj;
30786 fail:
30787 return NULL;
30788 }
30789
30790
30791 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30792 PyObject *resultobj = 0;
30793 wxWindow *arg1 = (wxWindow *) 0 ;
30794 wxPoint result;
30795 void *argp1 = 0 ;
30796 int res1 = 0 ;
30797 PyObject *swig_obj[1] ;
30798
30799 if (!args) SWIG_fail;
30800 swig_obj[0] = args;
30801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30802 if (!SWIG_IsOK(res1)) {
30803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30804 }
30805 arg1 = reinterpret_cast< wxWindow * >(argp1);
30806 {
30807 PyThreadState* __tstate = wxPyBeginAllowThreads();
30808 result = ((wxWindow const *)arg1)->GetPosition();
30809 wxPyEndAllowThreads(__tstate);
30810 if (PyErr_Occurred()) SWIG_fail;
30811 }
30812 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30813 return resultobj;
30814 fail:
30815 return NULL;
30816 }
30817
30818
30819 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30820 PyObject *resultobj = 0;
30821 wxWindow *arg1 = (wxWindow *) 0 ;
30822 int *arg2 = (int *) 0 ;
30823 int *arg3 = (int *) 0 ;
30824 void *argp1 = 0 ;
30825 int res1 = 0 ;
30826 int temp2 ;
30827 int res2 = SWIG_TMPOBJ ;
30828 int temp3 ;
30829 int res3 = SWIG_TMPOBJ ;
30830 PyObject *swig_obj[1] ;
30831
30832 arg2 = &temp2;
30833 arg3 = &temp3;
30834 if (!args) SWIG_fail;
30835 swig_obj[0] = args;
30836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30837 if (!SWIG_IsOK(res1)) {
30838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30839 }
30840 arg1 = reinterpret_cast< wxWindow * >(argp1);
30841 {
30842 PyThreadState* __tstate = wxPyBeginAllowThreads();
30843 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30844 wxPyEndAllowThreads(__tstate);
30845 if (PyErr_Occurred()) SWIG_fail;
30846 }
30847 resultobj = SWIG_Py_Void();
30848 if (SWIG_IsTmpObj(res2)) {
30849 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30850 } else {
30851 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30852 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30853 }
30854 if (SWIG_IsTmpObj(res3)) {
30855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30856 } else {
30857 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30859 }
30860 return resultobj;
30861 fail:
30862 return NULL;
30863 }
30864
30865
30866 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30867 PyObject *resultobj = 0;
30868 wxWindow *arg1 = (wxWindow *) 0 ;
30869 wxPoint result;
30870 void *argp1 = 0 ;
30871 int res1 = 0 ;
30872 PyObject *swig_obj[1] ;
30873
30874 if (!args) SWIG_fail;
30875 swig_obj[0] = args;
30876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30877 if (!SWIG_IsOK(res1)) {
30878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30879 }
30880 arg1 = reinterpret_cast< wxWindow * >(argp1);
30881 {
30882 PyThreadState* __tstate = wxPyBeginAllowThreads();
30883 result = ((wxWindow const *)arg1)->GetScreenPosition();
30884 wxPyEndAllowThreads(__tstate);
30885 if (PyErr_Occurred()) SWIG_fail;
30886 }
30887 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30888 return resultobj;
30889 fail:
30890 return NULL;
30891 }
30892
30893
30894 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30895 PyObject *resultobj = 0;
30896 wxWindow *arg1 = (wxWindow *) 0 ;
30897 int *arg2 = (int *) 0 ;
30898 int *arg3 = (int *) 0 ;
30899 void *argp1 = 0 ;
30900 int res1 = 0 ;
30901 int temp2 ;
30902 int res2 = SWIG_TMPOBJ ;
30903 int temp3 ;
30904 int res3 = SWIG_TMPOBJ ;
30905 PyObject *swig_obj[1] ;
30906
30907 arg2 = &temp2;
30908 arg3 = &temp3;
30909 if (!args) SWIG_fail;
30910 swig_obj[0] = args;
30911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30912 if (!SWIG_IsOK(res1)) {
30913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30914 }
30915 arg1 = reinterpret_cast< wxWindow * >(argp1);
30916 {
30917 PyThreadState* __tstate = wxPyBeginAllowThreads();
30918 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30919 wxPyEndAllowThreads(__tstate);
30920 if (PyErr_Occurred()) SWIG_fail;
30921 }
30922 resultobj = SWIG_Py_Void();
30923 if (SWIG_IsTmpObj(res2)) {
30924 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30925 } else {
30926 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30927 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30928 }
30929 if (SWIG_IsTmpObj(res3)) {
30930 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30931 } else {
30932 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30933 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30934 }
30935 return resultobj;
30936 fail:
30937 return NULL;
30938 }
30939
30940
30941 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30942 PyObject *resultobj = 0;
30943 wxWindow *arg1 = (wxWindow *) 0 ;
30944 wxRect result;
30945 void *argp1 = 0 ;
30946 int res1 = 0 ;
30947 PyObject *swig_obj[1] ;
30948
30949 if (!args) SWIG_fail;
30950 swig_obj[0] = args;
30951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30952 if (!SWIG_IsOK(res1)) {
30953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30954 }
30955 arg1 = reinterpret_cast< wxWindow * >(argp1);
30956 {
30957 PyThreadState* __tstate = wxPyBeginAllowThreads();
30958 result = ((wxWindow const *)arg1)->GetScreenRect();
30959 wxPyEndAllowThreads(__tstate);
30960 if (PyErr_Occurred()) SWIG_fail;
30961 }
30962 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30963 return resultobj;
30964 fail:
30965 return NULL;
30966 }
30967
30968
30969 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30970 PyObject *resultobj = 0;
30971 wxWindow *arg1 = (wxWindow *) 0 ;
30972 wxSize result;
30973 void *argp1 = 0 ;
30974 int res1 = 0 ;
30975 PyObject *swig_obj[1] ;
30976
30977 if (!args) SWIG_fail;
30978 swig_obj[0] = args;
30979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30980 if (!SWIG_IsOK(res1)) {
30981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30982 }
30983 arg1 = reinterpret_cast< wxWindow * >(argp1);
30984 {
30985 PyThreadState* __tstate = wxPyBeginAllowThreads();
30986 result = ((wxWindow const *)arg1)->GetSize();
30987 wxPyEndAllowThreads(__tstate);
30988 if (PyErr_Occurred()) SWIG_fail;
30989 }
30990 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30991 return resultobj;
30992 fail:
30993 return NULL;
30994 }
30995
30996
30997 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30998 PyObject *resultobj = 0;
30999 wxWindow *arg1 = (wxWindow *) 0 ;
31000 int *arg2 = (int *) 0 ;
31001 int *arg3 = (int *) 0 ;
31002 void *argp1 = 0 ;
31003 int res1 = 0 ;
31004 int temp2 ;
31005 int res2 = SWIG_TMPOBJ ;
31006 int temp3 ;
31007 int res3 = SWIG_TMPOBJ ;
31008 PyObject *swig_obj[1] ;
31009
31010 arg2 = &temp2;
31011 arg3 = &temp3;
31012 if (!args) SWIG_fail;
31013 swig_obj[0] = args;
31014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31015 if (!SWIG_IsOK(res1)) {
31016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31017 }
31018 arg1 = reinterpret_cast< wxWindow * >(argp1);
31019 {
31020 PyThreadState* __tstate = wxPyBeginAllowThreads();
31021 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31022 wxPyEndAllowThreads(__tstate);
31023 if (PyErr_Occurred()) SWIG_fail;
31024 }
31025 resultobj = SWIG_Py_Void();
31026 if (SWIG_IsTmpObj(res2)) {
31027 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31028 } else {
31029 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31030 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31031 }
31032 if (SWIG_IsTmpObj(res3)) {
31033 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31034 } else {
31035 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31036 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31037 }
31038 return resultobj;
31039 fail:
31040 return NULL;
31041 }
31042
31043
31044 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31045 PyObject *resultobj = 0;
31046 wxWindow *arg1 = (wxWindow *) 0 ;
31047 wxRect result;
31048 void *argp1 = 0 ;
31049 int res1 = 0 ;
31050 PyObject *swig_obj[1] ;
31051
31052 if (!args) SWIG_fail;
31053 swig_obj[0] = args;
31054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31055 if (!SWIG_IsOK(res1)) {
31056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31057 }
31058 arg1 = reinterpret_cast< wxWindow * >(argp1);
31059 {
31060 PyThreadState* __tstate = wxPyBeginAllowThreads();
31061 result = ((wxWindow const *)arg1)->GetRect();
31062 wxPyEndAllowThreads(__tstate);
31063 if (PyErr_Occurred()) SWIG_fail;
31064 }
31065 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31066 return resultobj;
31067 fail:
31068 return NULL;
31069 }
31070
31071
31072 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31073 PyObject *resultobj = 0;
31074 wxWindow *arg1 = (wxWindow *) 0 ;
31075 wxSize result;
31076 void *argp1 = 0 ;
31077 int res1 = 0 ;
31078 PyObject *swig_obj[1] ;
31079
31080 if (!args) SWIG_fail;
31081 swig_obj[0] = args;
31082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31083 if (!SWIG_IsOK(res1)) {
31084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31085 }
31086 arg1 = reinterpret_cast< wxWindow * >(argp1);
31087 {
31088 PyThreadState* __tstate = wxPyBeginAllowThreads();
31089 result = ((wxWindow const *)arg1)->GetClientSize();
31090 wxPyEndAllowThreads(__tstate);
31091 if (PyErr_Occurred()) SWIG_fail;
31092 }
31093 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31094 return resultobj;
31095 fail:
31096 return NULL;
31097 }
31098
31099
31100 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31101 PyObject *resultobj = 0;
31102 wxWindow *arg1 = (wxWindow *) 0 ;
31103 int *arg2 = (int *) 0 ;
31104 int *arg3 = (int *) 0 ;
31105 void *argp1 = 0 ;
31106 int res1 = 0 ;
31107 int temp2 ;
31108 int res2 = SWIG_TMPOBJ ;
31109 int temp3 ;
31110 int res3 = SWIG_TMPOBJ ;
31111 PyObject *swig_obj[1] ;
31112
31113 arg2 = &temp2;
31114 arg3 = &temp3;
31115 if (!args) SWIG_fail;
31116 swig_obj[0] = args;
31117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31118 if (!SWIG_IsOK(res1)) {
31119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31120 }
31121 arg1 = reinterpret_cast< wxWindow * >(argp1);
31122 {
31123 PyThreadState* __tstate = wxPyBeginAllowThreads();
31124 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31125 wxPyEndAllowThreads(__tstate);
31126 if (PyErr_Occurred()) SWIG_fail;
31127 }
31128 resultobj = SWIG_Py_Void();
31129 if (SWIG_IsTmpObj(res2)) {
31130 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31131 } else {
31132 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31133 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31134 }
31135 if (SWIG_IsTmpObj(res3)) {
31136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31137 } else {
31138 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31139 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31140 }
31141 return resultobj;
31142 fail:
31143 return NULL;
31144 }
31145
31146
31147 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31148 PyObject *resultobj = 0;
31149 wxWindow *arg1 = (wxWindow *) 0 ;
31150 wxPoint result;
31151 void *argp1 = 0 ;
31152 int res1 = 0 ;
31153 PyObject *swig_obj[1] ;
31154
31155 if (!args) SWIG_fail;
31156 swig_obj[0] = args;
31157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31158 if (!SWIG_IsOK(res1)) {
31159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31160 }
31161 arg1 = reinterpret_cast< wxWindow * >(argp1);
31162 {
31163 PyThreadState* __tstate = wxPyBeginAllowThreads();
31164 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31165 wxPyEndAllowThreads(__tstate);
31166 if (PyErr_Occurred()) SWIG_fail;
31167 }
31168 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31169 return resultobj;
31170 fail:
31171 return NULL;
31172 }
31173
31174
31175 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31176 PyObject *resultobj = 0;
31177 wxWindow *arg1 = (wxWindow *) 0 ;
31178 wxRect result;
31179 void *argp1 = 0 ;
31180 int res1 = 0 ;
31181 PyObject *swig_obj[1] ;
31182
31183 if (!args) SWIG_fail;
31184 swig_obj[0] = args;
31185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31186 if (!SWIG_IsOK(res1)) {
31187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31188 }
31189 arg1 = reinterpret_cast< wxWindow * >(argp1);
31190 {
31191 PyThreadState* __tstate = wxPyBeginAllowThreads();
31192 result = ((wxWindow const *)arg1)->GetClientRect();
31193 wxPyEndAllowThreads(__tstate);
31194 if (PyErr_Occurred()) SWIG_fail;
31195 }
31196 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31197 return resultobj;
31198 fail:
31199 return NULL;
31200 }
31201
31202
31203 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31204 PyObject *resultobj = 0;
31205 wxWindow *arg1 = (wxWindow *) 0 ;
31206 wxSize result;
31207 void *argp1 = 0 ;
31208 int res1 = 0 ;
31209 PyObject *swig_obj[1] ;
31210
31211 if (!args) SWIG_fail;
31212 swig_obj[0] = args;
31213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31214 if (!SWIG_IsOK(res1)) {
31215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31216 }
31217 arg1 = reinterpret_cast< wxWindow * >(argp1);
31218 {
31219 PyThreadState* __tstate = wxPyBeginAllowThreads();
31220 result = ((wxWindow const *)arg1)->GetBestSize();
31221 wxPyEndAllowThreads(__tstate);
31222 if (PyErr_Occurred()) SWIG_fail;
31223 }
31224 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31225 return resultobj;
31226 fail:
31227 return NULL;
31228 }
31229
31230
31231 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31232 PyObject *resultobj = 0;
31233 wxWindow *arg1 = (wxWindow *) 0 ;
31234 int *arg2 = (int *) 0 ;
31235 int *arg3 = (int *) 0 ;
31236 void *argp1 = 0 ;
31237 int res1 = 0 ;
31238 int temp2 ;
31239 int res2 = SWIG_TMPOBJ ;
31240 int temp3 ;
31241 int res3 = SWIG_TMPOBJ ;
31242 PyObject *swig_obj[1] ;
31243
31244 arg2 = &temp2;
31245 arg3 = &temp3;
31246 if (!args) SWIG_fail;
31247 swig_obj[0] = args;
31248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31249 if (!SWIG_IsOK(res1)) {
31250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31251 }
31252 arg1 = reinterpret_cast< wxWindow * >(argp1);
31253 {
31254 PyThreadState* __tstate = wxPyBeginAllowThreads();
31255 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31256 wxPyEndAllowThreads(__tstate);
31257 if (PyErr_Occurred()) SWIG_fail;
31258 }
31259 resultobj = SWIG_Py_Void();
31260 if (SWIG_IsTmpObj(res2)) {
31261 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31262 } else {
31263 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31264 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31265 }
31266 if (SWIG_IsTmpObj(res3)) {
31267 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31268 } else {
31269 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31270 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31271 }
31272 return resultobj;
31273 fail:
31274 return NULL;
31275 }
31276
31277
31278 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31279 PyObject *resultobj = 0;
31280 wxWindow *arg1 = (wxWindow *) 0 ;
31281 void *argp1 = 0 ;
31282 int res1 = 0 ;
31283 PyObject *swig_obj[1] ;
31284
31285 if (!args) SWIG_fail;
31286 swig_obj[0] = args;
31287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31288 if (!SWIG_IsOK(res1)) {
31289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31290 }
31291 arg1 = reinterpret_cast< wxWindow * >(argp1);
31292 {
31293 PyThreadState* __tstate = wxPyBeginAllowThreads();
31294 (arg1)->InvalidateBestSize();
31295 wxPyEndAllowThreads(__tstate);
31296 if (PyErr_Occurred()) SWIG_fail;
31297 }
31298 resultobj = SWIG_Py_Void();
31299 return resultobj;
31300 fail:
31301 return NULL;
31302 }
31303
31304
31305 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31306 PyObject *resultobj = 0;
31307 wxWindow *arg1 = (wxWindow *) 0 ;
31308 wxSize *arg2 = 0 ;
31309 void *argp1 = 0 ;
31310 int res1 = 0 ;
31311 wxSize temp2 ;
31312 PyObject * obj0 = 0 ;
31313 PyObject * obj1 = 0 ;
31314 char * kwnames[] = {
31315 (char *) "self",(char *) "size", NULL
31316 };
31317
31318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31320 if (!SWIG_IsOK(res1)) {
31321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31322 }
31323 arg1 = reinterpret_cast< wxWindow * >(argp1);
31324 {
31325 arg2 = &temp2;
31326 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31327 }
31328 {
31329 PyThreadState* __tstate = wxPyBeginAllowThreads();
31330 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31331 wxPyEndAllowThreads(__tstate);
31332 if (PyErr_Occurred()) SWIG_fail;
31333 }
31334 resultobj = SWIG_Py_Void();
31335 return resultobj;
31336 fail:
31337 return NULL;
31338 }
31339
31340
31341 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31342 PyObject *resultobj = 0;
31343 wxWindow *arg1 = (wxWindow *) 0 ;
31344 wxSize result;
31345 void *argp1 = 0 ;
31346 int res1 = 0 ;
31347 PyObject *swig_obj[1] ;
31348
31349 if (!args) SWIG_fail;
31350 swig_obj[0] = args;
31351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31352 if (!SWIG_IsOK(res1)) {
31353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31354 }
31355 arg1 = reinterpret_cast< wxWindow * >(argp1);
31356 {
31357 PyThreadState* __tstate = wxPyBeginAllowThreads();
31358 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31359 wxPyEndAllowThreads(__tstate);
31360 if (PyErr_Occurred()) SWIG_fail;
31361 }
31362 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31363 return resultobj;
31364 fail:
31365 return NULL;
31366 }
31367
31368
31369 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31370 PyObject *resultobj = 0;
31371 wxWindow *arg1 = (wxWindow *) 0 ;
31372 wxSize result;
31373 void *argp1 = 0 ;
31374 int res1 = 0 ;
31375 PyObject *swig_obj[1] ;
31376
31377 if (!args) SWIG_fail;
31378 swig_obj[0] = args;
31379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31380 if (!SWIG_IsOK(res1)) {
31381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31382 }
31383 arg1 = reinterpret_cast< wxWindow * >(argp1);
31384 {
31385 PyThreadState* __tstate = wxPyBeginAllowThreads();
31386 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31387 wxPyEndAllowThreads(__tstate);
31388 if (PyErr_Occurred()) SWIG_fail;
31389 }
31390 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31391 return resultobj;
31392 fail:
31393 return NULL;
31394 }
31395
31396
31397 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31398 PyObject *resultobj = 0;
31399 wxWindow *arg1 = (wxWindow *) 0 ;
31400 int arg2 = (int) wxBOTH ;
31401 void *argp1 = 0 ;
31402 int res1 = 0 ;
31403 int val2 ;
31404 int ecode2 = 0 ;
31405 PyObject * obj0 = 0 ;
31406 PyObject * obj1 = 0 ;
31407 char * kwnames[] = {
31408 (char *) "self",(char *) "direction", NULL
31409 };
31410
31411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31413 if (!SWIG_IsOK(res1)) {
31414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31415 }
31416 arg1 = reinterpret_cast< wxWindow * >(argp1);
31417 if (obj1) {
31418 ecode2 = SWIG_AsVal_int(obj1, &val2);
31419 if (!SWIG_IsOK(ecode2)) {
31420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31421 }
31422 arg2 = static_cast< int >(val2);
31423 }
31424 {
31425 PyThreadState* __tstate = wxPyBeginAllowThreads();
31426 (arg1)->Center(arg2);
31427 wxPyEndAllowThreads(__tstate);
31428 if (PyErr_Occurred()) SWIG_fail;
31429 }
31430 resultobj = SWIG_Py_Void();
31431 return resultobj;
31432 fail:
31433 return NULL;
31434 }
31435
31436
31437 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31438 PyObject *resultobj = 0;
31439 wxWindow *arg1 = (wxWindow *) 0 ;
31440 int arg2 = (int) wxBOTH ;
31441 void *argp1 = 0 ;
31442 int res1 = 0 ;
31443 int val2 ;
31444 int ecode2 = 0 ;
31445 PyObject * obj0 = 0 ;
31446 PyObject * obj1 = 0 ;
31447 char * kwnames[] = {
31448 (char *) "self",(char *) "dir", NULL
31449 };
31450
31451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31453 if (!SWIG_IsOK(res1)) {
31454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31455 }
31456 arg1 = reinterpret_cast< wxWindow * >(argp1);
31457 if (obj1) {
31458 ecode2 = SWIG_AsVal_int(obj1, &val2);
31459 if (!SWIG_IsOK(ecode2)) {
31460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31461 }
31462 arg2 = static_cast< int >(val2);
31463 }
31464 {
31465 PyThreadState* __tstate = wxPyBeginAllowThreads();
31466 (arg1)->CenterOnParent(arg2);
31467 wxPyEndAllowThreads(__tstate);
31468 if (PyErr_Occurred()) SWIG_fail;
31469 }
31470 resultobj = SWIG_Py_Void();
31471 return resultobj;
31472 fail:
31473 return NULL;
31474 }
31475
31476
31477 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31478 PyObject *resultobj = 0;
31479 wxWindow *arg1 = (wxWindow *) 0 ;
31480 void *argp1 = 0 ;
31481 int res1 = 0 ;
31482 PyObject *swig_obj[1] ;
31483
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_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31489 }
31490 arg1 = reinterpret_cast< wxWindow * >(argp1);
31491 {
31492 PyThreadState* __tstate = wxPyBeginAllowThreads();
31493 (arg1)->Fit();
31494 wxPyEndAllowThreads(__tstate);
31495 if (PyErr_Occurred()) SWIG_fail;
31496 }
31497 resultobj = SWIG_Py_Void();
31498 return resultobj;
31499 fail:
31500 return NULL;
31501 }
31502
31503
31504 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31505 PyObject *resultobj = 0;
31506 wxWindow *arg1 = (wxWindow *) 0 ;
31507 void *argp1 = 0 ;
31508 int res1 = 0 ;
31509 PyObject *swig_obj[1] ;
31510
31511 if (!args) SWIG_fail;
31512 swig_obj[0] = args;
31513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31514 if (!SWIG_IsOK(res1)) {
31515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31516 }
31517 arg1 = reinterpret_cast< wxWindow * >(argp1);
31518 {
31519 PyThreadState* __tstate = wxPyBeginAllowThreads();
31520 (arg1)->FitInside();
31521 wxPyEndAllowThreads(__tstate);
31522 if (PyErr_Occurred()) SWIG_fail;
31523 }
31524 resultobj = SWIG_Py_Void();
31525 return resultobj;
31526 fail:
31527 return NULL;
31528 }
31529
31530
31531 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31532 PyObject *resultobj = 0;
31533 wxWindow *arg1 = (wxWindow *) 0 ;
31534 int arg2 ;
31535 int arg3 ;
31536 int arg4 = (int) -1 ;
31537 int arg5 = (int) -1 ;
31538 int arg6 = (int) -1 ;
31539 int arg7 = (int) -1 ;
31540 void *argp1 = 0 ;
31541 int res1 = 0 ;
31542 int val2 ;
31543 int ecode2 = 0 ;
31544 int val3 ;
31545 int ecode3 = 0 ;
31546 int val4 ;
31547 int ecode4 = 0 ;
31548 int val5 ;
31549 int ecode5 = 0 ;
31550 int val6 ;
31551 int ecode6 = 0 ;
31552 int val7 ;
31553 int ecode7 = 0 ;
31554 PyObject * obj0 = 0 ;
31555 PyObject * obj1 = 0 ;
31556 PyObject * obj2 = 0 ;
31557 PyObject * obj3 = 0 ;
31558 PyObject * obj4 = 0 ;
31559 PyObject * obj5 = 0 ;
31560 PyObject * obj6 = 0 ;
31561 char * kwnames[] = {
31562 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31563 };
31564
31565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31567 if (!SWIG_IsOK(res1)) {
31568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31569 }
31570 arg1 = reinterpret_cast< wxWindow * >(argp1);
31571 ecode2 = SWIG_AsVal_int(obj1, &val2);
31572 if (!SWIG_IsOK(ecode2)) {
31573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31574 }
31575 arg2 = static_cast< int >(val2);
31576 ecode3 = SWIG_AsVal_int(obj2, &val3);
31577 if (!SWIG_IsOK(ecode3)) {
31578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31579 }
31580 arg3 = static_cast< int >(val3);
31581 if (obj3) {
31582 ecode4 = SWIG_AsVal_int(obj3, &val4);
31583 if (!SWIG_IsOK(ecode4)) {
31584 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31585 }
31586 arg4 = static_cast< int >(val4);
31587 }
31588 if (obj4) {
31589 ecode5 = SWIG_AsVal_int(obj4, &val5);
31590 if (!SWIG_IsOK(ecode5)) {
31591 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31592 }
31593 arg5 = static_cast< int >(val5);
31594 }
31595 if (obj5) {
31596 ecode6 = SWIG_AsVal_int(obj5, &val6);
31597 if (!SWIG_IsOK(ecode6)) {
31598 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31599 }
31600 arg6 = static_cast< int >(val6);
31601 }
31602 if (obj6) {
31603 ecode7 = SWIG_AsVal_int(obj6, &val7);
31604 if (!SWIG_IsOK(ecode7)) {
31605 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31606 }
31607 arg7 = static_cast< int >(val7);
31608 }
31609 {
31610 PyThreadState* __tstate = wxPyBeginAllowThreads();
31611 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31612 wxPyEndAllowThreads(__tstate);
31613 if (PyErr_Occurred()) SWIG_fail;
31614 }
31615 resultobj = SWIG_Py_Void();
31616 return resultobj;
31617 fail:
31618 return NULL;
31619 }
31620
31621
31622 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31623 PyObject *resultobj = 0;
31624 wxWindow *arg1 = (wxWindow *) 0 ;
31625 wxSize *arg2 = 0 ;
31626 wxSize const &arg3_defvalue = wxDefaultSize ;
31627 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31628 wxSize const &arg4_defvalue = wxDefaultSize ;
31629 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31630 void *argp1 = 0 ;
31631 int res1 = 0 ;
31632 wxSize temp2 ;
31633 wxSize temp3 ;
31634 wxSize temp4 ;
31635 PyObject * obj0 = 0 ;
31636 PyObject * obj1 = 0 ;
31637 PyObject * obj2 = 0 ;
31638 PyObject * obj3 = 0 ;
31639 char * kwnames[] = {
31640 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31641 };
31642
31643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31645 if (!SWIG_IsOK(res1)) {
31646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31647 }
31648 arg1 = reinterpret_cast< wxWindow * >(argp1);
31649 {
31650 arg2 = &temp2;
31651 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31652 }
31653 if (obj2) {
31654 {
31655 arg3 = &temp3;
31656 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31657 }
31658 }
31659 if (obj3) {
31660 {
31661 arg4 = &temp4;
31662 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31663 }
31664 }
31665 {
31666 PyThreadState* __tstate = wxPyBeginAllowThreads();
31667 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31668 wxPyEndAllowThreads(__tstate);
31669 if (PyErr_Occurred()) SWIG_fail;
31670 }
31671 resultobj = SWIG_Py_Void();
31672 return resultobj;
31673 fail:
31674 return NULL;
31675 }
31676
31677
31678 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31679 PyObject *resultobj = 0;
31680 wxWindow *arg1 = (wxWindow *) 0 ;
31681 int arg2 ;
31682 int arg3 ;
31683 int arg4 = (int) -1 ;
31684 int arg5 = (int) -1 ;
31685 void *argp1 = 0 ;
31686 int res1 = 0 ;
31687 int val2 ;
31688 int ecode2 = 0 ;
31689 int val3 ;
31690 int ecode3 = 0 ;
31691 int val4 ;
31692 int ecode4 = 0 ;
31693 int val5 ;
31694 int ecode5 = 0 ;
31695 PyObject * obj0 = 0 ;
31696 PyObject * obj1 = 0 ;
31697 PyObject * obj2 = 0 ;
31698 PyObject * obj3 = 0 ;
31699 PyObject * obj4 = 0 ;
31700 char * kwnames[] = {
31701 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31702 };
31703
31704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31706 if (!SWIG_IsOK(res1)) {
31707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31708 }
31709 arg1 = reinterpret_cast< wxWindow * >(argp1);
31710 ecode2 = SWIG_AsVal_int(obj1, &val2);
31711 if (!SWIG_IsOK(ecode2)) {
31712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31713 }
31714 arg2 = static_cast< int >(val2);
31715 ecode3 = SWIG_AsVal_int(obj2, &val3);
31716 if (!SWIG_IsOK(ecode3)) {
31717 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31718 }
31719 arg3 = static_cast< int >(val3);
31720 if (obj3) {
31721 ecode4 = SWIG_AsVal_int(obj3, &val4);
31722 if (!SWIG_IsOK(ecode4)) {
31723 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31724 }
31725 arg4 = static_cast< int >(val4);
31726 }
31727 if (obj4) {
31728 ecode5 = SWIG_AsVal_int(obj4, &val5);
31729 if (!SWIG_IsOK(ecode5)) {
31730 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31731 }
31732 arg5 = static_cast< int >(val5);
31733 }
31734 {
31735 PyThreadState* __tstate = wxPyBeginAllowThreads();
31736 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31737 wxPyEndAllowThreads(__tstate);
31738 if (PyErr_Occurred()) SWIG_fail;
31739 }
31740 resultobj = SWIG_Py_Void();
31741 return resultobj;
31742 fail:
31743 return NULL;
31744 }
31745
31746
31747 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31748 PyObject *resultobj = 0;
31749 wxWindow *arg1 = (wxWindow *) 0 ;
31750 wxSize *arg2 = 0 ;
31751 wxSize const &arg3_defvalue = wxDefaultSize ;
31752 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31753 void *argp1 = 0 ;
31754 int res1 = 0 ;
31755 wxSize temp2 ;
31756 wxSize temp3 ;
31757 PyObject * obj0 = 0 ;
31758 PyObject * obj1 = 0 ;
31759 PyObject * obj2 = 0 ;
31760 char * kwnames[] = {
31761 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31762 };
31763
31764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31766 if (!SWIG_IsOK(res1)) {
31767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31768 }
31769 arg1 = reinterpret_cast< wxWindow * >(argp1);
31770 {
31771 arg2 = &temp2;
31772 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31773 }
31774 if (obj2) {
31775 {
31776 arg3 = &temp3;
31777 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31778 }
31779 }
31780 {
31781 PyThreadState* __tstate = wxPyBeginAllowThreads();
31782 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31783 wxPyEndAllowThreads(__tstate);
31784 if (PyErr_Occurred()) SWIG_fail;
31785 }
31786 resultobj = SWIG_Py_Void();
31787 return resultobj;
31788 fail:
31789 return NULL;
31790 }
31791
31792
31793 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31794 PyObject *resultobj = 0;
31795 wxWindow *arg1 = (wxWindow *) 0 ;
31796 wxSize result;
31797 void *argp1 = 0 ;
31798 int res1 = 0 ;
31799 PyObject *swig_obj[1] ;
31800
31801 if (!args) SWIG_fail;
31802 swig_obj[0] = args;
31803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31804 if (!SWIG_IsOK(res1)) {
31805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31806 }
31807 arg1 = reinterpret_cast< wxWindow * >(argp1);
31808 {
31809 PyThreadState* __tstate = wxPyBeginAllowThreads();
31810 result = ((wxWindow const *)arg1)->GetMaxSize();
31811 wxPyEndAllowThreads(__tstate);
31812 if (PyErr_Occurred()) SWIG_fail;
31813 }
31814 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31815 return resultobj;
31816 fail:
31817 return NULL;
31818 }
31819
31820
31821 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31822 PyObject *resultobj = 0;
31823 wxWindow *arg1 = (wxWindow *) 0 ;
31824 wxSize result;
31825 void *argp1 = 0 ;
31826 int res1 = 0 ;
31827 PyObject *swig_obj[1] ;
31828
31829 if (!args) SWIG_fail;
31830 swig_obj[0] = args;
31831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31832 if (!SWIG_IsOK(res1)) {
31833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31834 }
31835 arg1 = reinterpret_cast< wxWindow * >(argp1);
31836 {
31837 PyThreadState* __tstate = wxPyBeginAllowThreads();
31838 result = ((wxWindow const *)arg1)->GetMinSize();
31839 wxPyEndAllowThreads(__tstate);
31840 if (PyErr_Occurred()) SWIG_fail;
31841 }
31842 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31843 return resultobj;
31844 fail:
31845 return NULL;
31846 }
31847
31848
31849 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31850 PyObject *resultobj = 0;
31851 wxWindow *arg1 = (wxWindow *) 0 ;
31852 wxSize *arg2 = 0 ;
31853 void *argp1 = 0 ;
31854 int res1 = 0 ;
31855 wxSize temp2 ;
31856 PyObject * obj0 = 0 ;
31857 PyObject * obj1 = 0 ;
31858 char * kwnames[] = {
31859 (char *) "self",(char *) "minSize", NULL
31860 };
31861
31862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31864 if (!SWIG_IsOK(res1)) {
31865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31866 }
31867 arg1 = reinterpret_cast< wxWindow * >(argp1);
31868 {
31869 arg2 = &temp2;
31870 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31871 }
31872 {
31873 PyThreadState* __tstate = wxPyBeginAllowThreads();
31874 (arg1)->SetMinSize((wxSize const &)*arg2);
31875 wxPyEndAllowThreads(__tstate);
31876 if (PyErr_Occurred()) SWIG_fail;
31877 }
31878 resultobj = SWIG_Py_Void();
31879 return resultobj;
31880 fail:
31881 return NULL;
31882 }
31883
31884
31885 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31886 PyObject *resultobj = 0;
31887 wxWindow *arg1 = (wxWindow *) 0 ;
31888 wxSize *arg2 = 0 ;
31889 void *argp1 = 0 ;
31890 int res1 = 0 ;
31891 wxSize temp2 ;
31892 PyObject * obj0 = 0 ;
31893 PyObject * obj1 = 0 ;
31894 char * kwnames[] = {
31895 (char *) "self",(char *) "maxSize", NULL
31896 };
31897
31898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31900 if (!SWIG_IsOK(res1)) {
31901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31902 }
31903 arg1 = reinterpret_cast< wxWindow * >(argp1);
31904 {
31905 arg2 = &temp2;
31906 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31907 }
31908 {
31909 PyThreadState* __tstate = wxPyBeginAllowThreads();
31910 (arg1)->SetMaxSize((wxSize const &)*arg2);
31911 wxPyEndAllowThreads(__tstate);
31912 if (PyErr_Occurred()) SWIG_fail;
31913 }
31914 resultobj = SWIG_Py_Void();
31915 return resultobj;
31916 fail:
31917 return NULL;
31918 }
31919
31920
31921 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31922 PyObject *resultobj = 0;
31923 wxWindow *arg1 = (wxWindow *) 0 ;
31924 int result;
31925 void *argp1 = 0 ;
31926 int res1 = 0 ;
31927 PyObject *swig_obj[1] ;
31928
31929 if (!args) SWIG_fail;
31930 swig_obj[0] = args;
31931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31932 if (!SWIG_IsOK(res1)) {
31933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31934 }
31935 arg1 = reinterpret_cast< wxWindow * >(argp1);
31936 {
31937 PyThreadState* __tstate = wxPyBeginAllowThreads();
31938 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31939 wxPyEndAllowThreads(__tstate);
31940 if (PyErr_Occurred()) SWIG_fail;
31941 }
31942 resultobj = SWIG_From_int(static_cast< int >(result));
31943 return resultobj;
31944 fail:
31945 return NULL;
31946 }
31947
31948
31949 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31950 PyObject *resultobj = 0;
31951 wxWindow *arg1 = (wxWindow *) 0 ;
31952 int result;
31953 void *argp1 = 0 ;
31954 int res1 = 0 ;
31955 PyObject *swig_obj[1] ;
31956
31957 if (!args) SWIG_fail;
31958 swig_obj[0] = args;
31959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31960 if (!SWIG_IsOK(res1)) {
31961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31962 }
31963 arg1 = reinterpret_cast< wxWindow * >(argp1);
31964 {
31965 PyThreadState* __tstate = wxPyBeginAllowThreads();
31966 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31967 wxPyEndAllowThreads(__tstate);
31968 if (PyErr_Occurred()) SWIG_fail;
31969 }
31970 resultobj = SWIG_From_int(static_cast< int >(result));
31971 return resultobj;
31972 fail:
31973 return NULL;
31974 }
31975
31976
31977 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31978 PyObject *resultobj = 0;
31979 wxWindow *arg1 = (wxWindow *) 0 ;
31980 int result;
31981 void *argp1 = 0 ;
31982 int res1 = 0 ;
31983 PyObject *swig_obj[1] ;
31984
31985 if (!args) SWIG_fail;
31986 swig_obj[0] = args;
31987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31988 if (!SWIG_IsOK(res1)) {
31989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31990 }
31991 arg1 = reinterpret_cast< wxWindow * >(argp1);
31992 {
31993 PyThreadState* __tstate = wxPyBeginAllowThreads();
31994 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31995 wxPyEndAllowThreads(__tstate);
31996 if (PyErr_Occurred()) SWIG_fail;
31997 }
31998 resultobj = SWIG_From_int(static_cast< int >(result));
31999 return resultobj;
32000 fail:
32001 return NULL;
32002 }
32003
32004
32005 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32006 PyObject *resultobj = 0;
32007 wxWindow *arg1 = (wxWindow *) 0 ;
32008 int result;
32009 void *argp1 = 0 ;
32010 int res1 = 0 ;
32011 PyObject *swig_obj[1] ;
32012
32013 if (!args) SWIG_fail;
32014 swig_obj[0] = args;
32015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32016 if (!SWIG_IsOK(res1)) {
32017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32018 }
32019 arg1 = reinterpret_cast< wxWindow * >(argp1);
32020 {
32021 PyThreadState* __tstate = wxPyBeginAllowThreads();
32022 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32023 wxPyEndAllowThreads(__tstate);
32024 if (PyErr_Occurred()) SWIG_fail;
32025 }
32026 resultobj = SWIG_From_int(static_cast< int >(result));
32027 return resultobj;
32028 fail:
32029 return NULL;
32030 }
32031
32032
32033 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32034 PyObject *resultobj = 0;
32035 wxWindow *arg1 = (wxWindow *) 0 ;
32036 wxSize *arg2 = 0 ;
32037 void *argp1 = 0 ;
32038 int res1 = 0 ;
32039 wxSize temp2 ;
32040 PyObject * obj0 = 0 ;
32041 PyObject * obj1 = 0 ;
32042 char * kwnames[] = {
32043 (char *) "self",(char *) "size", NULL
32044 };
32045
32046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32048 if (!SWIG_IsOK(res1)) {
32049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32050 }
32051 arg1 = reinterpret_cast< wxWindow * >(argp1);
32052 {
32053 arg2 = &temp2;
32054 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32055 }
32056 {
32057 PyThreadState* __tstate = wxPyBeginAllowThreads();
32058 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32059 wxPyEndAllowThreads(__tstate);
32060 if (PyErr_Occurred()) SWIG_fail;
32061 }
32062 resultobj = SWIG_Py_Void();
32063 return resultobj;
32064 fail:
32065 return NULL;
32066 }
32067
32068
32069 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32070 PyObject *resultobj = 0;
32071 wxWindow *arg1 = (wxWindow *) 0 ;
32072 int arg2 ;
32073 int arg3 ;
32074 void *argp1 = 0 ;
32075 int res1 = 0 ;
32076 int val2 ;
32077 int ecode2 = 0 ;
32078 int val3 ;
32079 int ecode3 = 0 ;
32080 PyObject * obj0 = 0 ;
32081 PyObject * obj1 = 0 ;
32082 PyObject * obj2 = 0 ;
32083 char * kwnames[] = {
32084 (char *) "self",(char *) "w",(char *) "h", NULL
32085 };
32086
32087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32089 if (!SWIG_IsOK(res1)) {
32090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32091 }
32092 arg1 = reinterpret_cast< wxWindow * >(argp1);
32093 ecode2 = SWIG_AsVal_int(obj1, &val2);
32094 if (!SWIG_IsOK(ecode2)) {
32095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32096 }
32097 arg2 = static_cast< int >(val2);
32098 ecode3 = SWIG_AsVal_int(obj2, &val3);
32099 if (!SWIG_IsOK(ecode3)) {
32100 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32101 }
32102 arg3 = static_cast< int >(val3);
32103 {
32104 PyThreadState* __tstate = wxPyBeginAllowThreads();
32105 (arg1)->SetVirtualSize(arg2,arg3);
32106 wxPyEndAllowThreads(__tstate);
32107 if (PyErr_Occurred()) SWIG_fail;
32108 }
32109 resultobj = SWIG_Py_Void();
32110 return resultobj;
32111 fail:
32112 return NULL;
32113 }
32114
32115
32116 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32117 PyObject *resultobj = 0;
32118 wxWindow *arg1 = (wxWindow *) 0 ;
32119 wxSize result;
32120 void *argp1 = 0 ;
32121 int res1 = 0 ;
32122 PyObject *swig_obj[1] ;
32123
32124 if (!args) SWIG_fail;
32125 swig_obj[0] = args;
32126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32127 if (!SWIG_IsOK(res1)) {
32128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32129 }
32130 arg1 = reinterpret_cast< wxWindow * >(argp1);
32131 {
32132 PyThreadState* __tstate = wxPyBeginAllowThreads();
32133 result = ((wxWindow const *)arg1)->GetVirtualSize();
32134 wxPyEndAllowThreads(__tstate);
32135 if (PyErr_Occurred()) SWIG_fail;
32136 }
32137 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32138 return resultobj;
32139 fail:
32140 return NULL;
32141 }
32142
32143
32144 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32145 PyObject *resultobj = 0;
32146 wxWindow *arg1 = (wxWindow *) 0 ;
32147 int *arg2 = (int *) 0 ;
32148 int *arg3 = (int *) 0 ;
32149 void *argp1 = 0 ;
32150 int res1 = 0 ;
32151 int temp2 ;
32152 int res2 = SWIG_TMPOBJ ;
32153 int temp3 ;
32154 int res3 = SWIG_TMPOBJ ;
32155 PyObject *swig_obj[1] ;
32156
32157 arg2 = &temp2;
32158 arg3 = &temp3;
32159 if (!args) SWIG_fail;
32160 swig_obj[0] = args;
32161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32162 if (!SWIG_IsOK(res1)) {
32163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32164 }
32165 arg1 = reinterpret_cast< wxWindow * >(argp1);
32166 {
32167 PyThreadState* __tstate = wxPyBeginAllowThreads();
32168 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32169 wxPyEndAllowThreads(__tstate);
32170 if (PyErr_Occurred()) SWIG_fail;
32171 }
32172 resultobj = SWIG_Py_Void();
32173 if (SWIG_IsTmpObj(res2)) {
32174 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32175 } else {
32176 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32177 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32178 }
32179 if (SWIG_IsTmpObj(res3)) {
32180 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32181 } else {
32182 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32183 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32184 }
32185 return resultobj;
32186 fail:
32187 return NULL;
32188 }
32189
32190
32191 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32192 PyObject *resultobj = 0;
32193 wxWindow *arg1 = (wxWindow *) 0 ;
32194 wxSize result;
32195 void *argp1 = 0 ;
32196 int res1 = 0 ;
32197 PyObject *swig_obj[1] ;
32198
32199 if (!args) SWIG_fail;
32200 swig_obj[0] = args;
32201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32202 if (!SWIG_IsOK(res1)) {
32203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32204 }
32205 arg1 = reinterpret_cast< wxWindow * >(argp1);
32206 {
32207 PyThreadState* __tstate = wxPyBeginAllowThreads();
32208 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32209 wxPyEndAllowThreads(__tstate);
32210 if (PyErr_Occurred()) SWIG_fail;
32211 }
32212 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32213 return resultobj;
32214 fail:
32215 return NULL;
32216 }
32217
32218
32219 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32220 PyObject *resultobj = 0;
32221 wxWindow *arg1 = (wxWindow *) 0 ;
32222 bool arg2 = (bool) true ;
32223 bool result;
32224 void *argp1 = 0 ;
32225 int res1 = 0 ;
32226 bool val2 ;
32227 int ecode2 = 0 ;
32228 PyObject * obj0 = 0 ;
32229 PyObject * obj1 = 0 ;
32230 char * kwnames[] = {
32231 (char *) "self",(char *) "show", NULL
32232 };
32233
32234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32236 if (!SWIG_IsOK(res1)) {
32237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32238 }
32239 arg1 = reinterpret_cast< wxWindow * >(argp1);
32240 if (obj1) {
32241 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32242 if (!SWIG_IsOK(ecode2)) {
32243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32244 }
32245 arg2 = static_cast< bool >(val2);
32246 }
32247 {
32248 PyThreadState* __tstate = wxPyBeginAllowThreads();
32249 result = (bool)(arg1)->Show(arg2);
32250 wxPyEndAllowThreads(__tstate);
32251 if (PyErr_Occurred()) SWIG_fail;
32252 }
32253 {
32254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32255 }
32256 return resultobj;
32257 fail:
32258 return NULL;
32259 }
32260
32261
32262 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32263 PyObject *resultobj = 0;
32264 wxWindow *arg1 = (wxWindow *) 0 ;
32265 bool result;
32266 void *argp1 = 0 ;
32267 int res1 = 0 ;
32268 PyObject *swig_obj[1] ;
32269
32270 if (!args) SWIG_fail;
32271 swig_obj[0] = args;
32272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32273 if (!SWIG_IsOK(res1)) {
32274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32275 }
32276 arg1 = reinterpret_cast< wxWindow * >(argp1);
32277 {
32278 PyThreadState* __tstate = wxPyBeginAllowThreads();
32279 result = (bool)(arg1)->Hide();
32280 wxPyEndAllowThreads(__tstate);
32281 if (PyErr_Occurred()) SWIG_fail;
32282 }
32283 {
32284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32285 }
32286 return resultobj;
32287 fail:
32288 return NULL;
32289 }
32290
32291
32292 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32293 PyObject *resultobj = 0;
32294 wxWindow *arg1 = (wxWindow *) 0 ;
32295 bool arg2 = (bool) true ;
32296 bool result;
32297 void *argp1 = 0 ;
32298 int res1 = 0 ;
32299 bool val2 ;
32300 int ecode2 = 0 ;
32301 PyObject * obj0 = 0 ;
32302 PyObject * obj1 = 0 ;
32303 char * kwnames[] = {
32304 (char *) "self",(char *) "enable", NULL
32305 };
32306
32307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32309 if (!SWIG_IsOK(res1)) {
32310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32311 }
32312 arg1 = reinterpret_cast< wxWindow * >(argp1);
32313 if (obj1) {
32314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32315 if (!SWIG_IsOK(ecode2)) {
32316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32317 }
32318 arg2 = static_cast< bool >(val2);
32319 }
32320 {
32321 PyThreadState* __tstate = wxPyBeginAllowThreads();
32322 result = (bool)(arg1)->Enable(arg2);
32323 wxPyEndAllowThreads(__tstate);
32324 if (PyErr_Occurred()) SWIG_fail;
32325 }
32326 {
32327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32328 }
32329 return resultobj;
32330 fail:
32331 return NULL;
32332 }
32333
32334
32335 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32336 PyObject *resultobj = 0;
32337 wxWindow *arg1 = (wxWindow *) 0 ;
32338 bool result;
32339 void *argp1 = 0 ;
32340 int res1 = 0 ;
32341 PyObject *swig_obj[1] ;
32342
32343 if (!args) SWIG_fail;
32344 swig_obj[0] = args;
32345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32346 if (!SWIG_IsOK(res1)) {
32347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32348 }
32349 arg1 = reinterpret_cast< wxWindow * >(argp1);
32350 {
32351 PyThreadState* __tstate = wxPyBeginAllowThreads();
32352 result = (bool)(arg1)->Disable();
32353 wxPyEndAllowThreads(__tstate);
32354 if (PyErr_Occurred()) SWIG_fail;
32355 }
32356 {
32357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32358 }
32359 return resultobj;
32360 fail:
32361 return NULL;
32362 }
32363
32364
32365 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32366 PyObject *resultobj = 0;
32367 wxWindow *arg1 = (wxWindow *) 0 ;
32368 bool result;
32369 void *argp1 = 0 ;
32370 int res1 = 0 ;
32371 PyObject *swig_obj[1] ;
32372
32373 if (!args) SWIG_fail;
32374 swig_obj[0] = args;
32375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32376 if (!SWIG_IsOK(res1)) {
32377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32378 }
32379 arg1 = reinterpret_cast< wxWindow * >(argp1);
32380 {
32381 PyThreadState* __tstate = wxPyBeginAllowThreads();
32382 result = (bool)((wxWindow const *)arg1)->IsShown();
32383 wxPyEndAllowThreads(__tstate);
32384 if (PyErr_Occurred()) SWIG_fail;
32385 }
32386 {
32387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32388 }
32389 return resultobj;
32390 fail:
32391 return NULL;
32392 }
32393
32394
32395 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32396 PyObject *resultobj = 0;
32397 wxWindow *arg1 = (wxWindow *) 0 ;
32398 bool result;
32399 void *argp1 = 0 ;
32400 int res1 = 0 ;
32401 PyObject *swig_obj[1] ;
32402
32403 if (!args) SWIG_fail;
32404 swig_obj[0] = args;
32405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32406 if (!SWIG_IsOK(res1)) {
32407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32408 }
32409 arg1 = reinterpret_cast< wxWindow * >(argp1);
32410 {
32411 PyThreadState* __tstate = wxPyBeginAllowThreads();
32412 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32413 wxPyEndAllowThreads(__tstate);
32414 if (PyErr_Occurred()) SWIG_fail;
32415 }
32416 {
32417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32418 }
32419 return resultobj;
32420 fail:
32421 return NULL;
32422 }
32423
32424
32425 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32426 PyObject *resultobj = 0;
32427 wxWindow *arg1 = (wxWindow *) 0 ;
32428 long arg2 ;
32429 void *argp1 = 0 ;
32430 int res1 = 0 ;
32431 long val2 ;
32432 int ecode2 = 0 ;
32433 PyObject * obj0 = 0 ;
32434 PyObject * obj1 = 0 ;
32435 char * kwnames[] = {
32436 (char *) "self",(char *) "style", NULL
32437 };
32438
32439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32441 if (!SWIG_IsOK(res1)) {
32442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32443 }
32444 arg1 = reinterpret_cast< wxWindow * >(argp1);
32445 ecode2 = SWIG_AsVal_long(obj1, &val2);
32446 if (!SWIG_IsOK(ecode2)) {
32447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32448 }
32449 arg2 = static_cast< long >(val2);
32450 {
32451 PyThreadState* __tstate = wxPyBeginAllowThreads();
32452 (arg1)->SetWindowStyleFlag(arg2);
32453 wxPyEndAllowThreads(__tstate);
32454 if (PyErr_Occurred()) SWIG_fail;
32455 }
32456 resultobj = SWIG_Py_Void();
32457 return resultobj;
32458 fail:
32459 return NULL;
32460 }
32461
32462
32463 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32464 PyObject *resultobj = 0;
32465 wxWindow *arg1 = (wxWindow *) 0 ;
32466 long result;
32467 void *argp1 = 0 ;
32468 int res1 = 0 ;
32469 PyObject *swig_obj[1] ;
32470
32471 if (!args) SWIG_fail;
32472 swig_obj[0] = args;
32473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32474 if (!SWIG_IsOK(res1)) {
32475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32476 }
32477 arg1 = reinterpret_cast< wxWindow * >(argp1);
32478 {
32479 PyThreadState* __tstate = wxPyBeginAllowThreads();
32480 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32481 wxPyEndAllowThreads(__tstate);
32482 if (PyErr_Occurred()) SWIG_fail;
32483 }
32484 resultobj = SWIG_From_long(static_cast< long >(result));
32485 return resultobj;
32486 fail:
32487 return NULL;
32488 }
32489
32490
32491 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32492 PyObject *resultobj = 0;
32493 wxWindow *arg1 = (wxWindow *) 0 ;
32494 int arg2 ;
32495 bool result;
32496 void *argp1 = 0 ;
32497 int res1 = 0 ;
32498 int val2 ;
32499 int ecode2 = 0 ;
32500 PyObject * obj0 = 0 ;
32501 PyObject * obj1 = 0 ;
32502 char * kwnames[] = {
32503 (char *) "self",(char *) "flag", NULL
32504 };
32505
32506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32508 if (!SWIG_IsOK(res1)) {
32509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32510 }
32511 arg1 = reinterpret_cast< wxWindow * >(argp1);
32512 ecode2 = SWIG_AsVal_int(obj1, &val2);
32513 if (!SWIG_IsOK(ecode2)) {
32514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32515 }
32516 arg2 = static_cast< int >(val2);
32517 {
32518 PyThreadState* __tstate = wxPyBeginAllowThreads();
32519 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32520 wxPyEndAllowThreads(__tstate);
32521 if (PyErr_Occurred()) SWIG_fail;
32522 }
32523 {
32524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32525 }
32526 return resultobj;
32527 fail:
32528 return NULL;
32529 }
32530
32531
32532 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32533 PyObject *resultobj = 0;
32534 wxWindow *arg1 = (wxWindow *) 0 ;
32535 bool result;
32536 void *argp1 = 0 ;
32537 int res1 = 0 ;
32538 PyObject *swig_obj[1] ;
32539
32540 if (!args) SWIG_fail;
32541 swig_obj[0] = args;
32542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32543 if (!SWIG_IsOK(res1)) {
32544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32545 }
32546 arg1 = reinterpret_cast< wxWindow * >(argp1);
32547 {
32548 PyThreadState* __tstate = wxPyBeginAllowThreads();
32549 result = (bool)((wxWindow const *)arg1)->IsRetained();
32550 wxPyEndAllowThreads(__tstate);
32551 if (PyErr_Occurred()) SWIG_fail;
32552 }
32553 {
32554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32555 }
32556 return resultobj;
32557 fail:
32558 return NULL;
32559 }
32560
32561
32562 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32563 PyObject *resultobj = 0;
32564 wxWindow *arg1 = (wxWindow *) 0 ;
32565 long arg2 ;
32566 void *argp1 = 0 ;
32567 int res1 = 0 ;
32568 long val2 ;
32569 int ecode2 = 0 ;
32570 PyObject * obj0 = 0 ;
32571 PyObject * obj1 = 0 ;
32572 char * kwnames[] = {
32573 (char *) "self",(char *) "exStyle", NULL
32574 };
32575
32576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32578 if (!SWIG_IsOK(res1)) {
32579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32580 }
32581 arg1 = reinterpret_cast< wxWindow * >(argp1);
32582 ecode2 = SWIG_AsVal_long(obj1, &val2);
32583 if (!SWIG_IsOK(ecode2)) {
32584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32585 }
32586 arg2 = static_cast< long >(val2);
32587 {
32588 PyThreadState* __tstate = wxPyBeginAllowThreads();
32589 (arg1)->SetExtraStyle(arg2);
32590 wxPyEndAllowThreads(__tstate);
32591 if (PyErr_Occurred()) SWIG_fail;
32592 }
32593 resultobj = SWIG_Py_Void();
32594 return resultobj;
32595 fail:
32596 return NULL;
32597 }
32598
32599
32600 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32601 PyObject *resultobj = 0;
32602 wxWindow *arg1 = (wxWindow *) 0 ;
32603 long result;
32604 void *argp1 = 0 ;
32605 int res1 = 0 ;
32606 PyObject *swig_obj[1] ;
32607
32608 if (!args) SWIG_fail;
32609 swig_obj[0] = args;
32610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32611 if (!SWIG_IsOK(res1)) {
32612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32613 }
32614 arg1 = reinterpret_cast< wxWindow * >(argp1);
32615 {
32616 PyThreadState* __tstate = wxPyBeginAllowThreads();
32617 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32618 wxPyEndAllowThreads(__tstate);
32619 if (PyErr_Occurred()) SWIG_fail;
32620 }
32621 resultobj = SWIG_From_long(static_cast< long >(result));
32622 return resultobj;
32623 fail:
32624 return NULL;
32625 }
32626
32627
32628 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32629 PyObject *resultobj = 0;
32630 wxWindow *arg1 = (wxWindow *) 0 ;
32631 bool arg2 = (bool) true ;
32632 void *argp1 = 0 ;
32633 int res1 = 0 ;
32634 bool val2 ;
32635 int ecode2 = 0 ;
32636 PyObject * obj0 = 0 ;
32637 PyObject * obj1 = 0 ;
32638 char * kwnames[] = {
32639 (char *) "self",(char *) "modal", NULL
32640 };
32641
32642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32644 if (!SWIG_IsOK(res1)) {
32645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32646 }
32647 arg1 = reinterpret_cast< wxWindow * >(argp1);
32648 if (obj1) {
32649 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32650 if (!SWIG_IsOK(ecode2)) {
32651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32652 }
32653 arg2 = static_cast< bool >(val2);
32654 }
32655 {
32656 PyThreadState* __tstate = wxPyBeginAllowThreads();
32657 (arg1)->MakeModal(arg2);
32658 wxPyEndAllowThreads(__tstate);
32659 if (PyErr_Occurred()) SWIG_fail;
32660 }
32661 resultobj = SWIG_Py_Void();
32662 return resultobj;
32663 fail:
32664 return NULL;
32665 }
32666
32667
32668 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32669 PyObject *resultobj = 0;
32670 wxWindow *arg1 = (wxWindow *) 0 ;
32671 bool arg2 ;
32672 void *argp1 = 0 ;
32673 int res1 = 0 ;
32674 bool val2 ;
32675 int ecode2 = 0 ;
32676 PyObject * obj0 = 0 ;
32677 PyObject * obj1 = 0 ;
32678 char * kwnames[] = {
32679 (char *) "self",(char *) "enableTheme", NULL
32680 };
32681
32682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32684 if (!SWIG_IsOK(res1)) {
32685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32686 }
32687 arg1 = reinterpret_cast< wxWindow * >(argp1);
32688 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32689 if (!SWIG_IsOK(ecode2)) {
32690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32691 }
32692 arg2 = static_cast< bool >(val2);
32693 {
32694 PyThreadState* __tstate = wxPyBeginAllowThreads();
32695 (arg1)->SetThemeEnabled(arg2);
32696 wxPyEndAllowThreads(__tstate);
32697 if (PyErr_Occurred()) SWIG_fail;
32698 }
32699 resultobj = SWIG_Py_Void();
32700 return resultobj;
32701 fail:
32702 return NULL;
32703 }
32704
32705
32706 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32707 PyObject *resultobj = 0;
32708 wxWindow *arg1 = (wxWindow *) 0 ;
32709 bool result;
32710 void *argp1 = 0 ;
32711 int res1 = 0 ;
32712 PyObject *swig_obj[1] ;
32713
32714 if (!args) SWIG_fail;
32715 swig_obj[0] = args;
32716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32717 if (!SWIG_IsOK(res1)) {
32718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32719 }
32720 arg1 = reinterpret_cast< wxWindow * >(argp1);
32721 {
32722 PyThreadState* __tstate = wxPyBeginAllowThreads();
32723 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32724 wxPyEndAllowThreads(__tstate);
32725 if (PyErr_Occurred()) SWIG_fail;
32726 }
32727 {
32728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32729 }
32730 return resultobj;
32731 fail:
32732 return NULL;
32733 }
32734
32735
32736 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32737 PyObject *resultobj = 0;
32738 wxWindow *arg1 = (wxWindow *) 0 ;
32739 void *argp1 = 0 ;
32740 int res1 = 0 ;
32741 PyObject *swig_obj[1] ;
32742
32743 if (!args) SWIG_fail;
32744 swig_obj[0] = args;
32745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32746 if (!SWIG_IsOK(res1)) {
32747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32748 }
32749 arg1 = reinterpret_cast< wxWindow * >(argp1);
32750 {
32751 PyThreadState* __tstate = wxPyBeginAllowThreads();
32752 (arg1)->SetFocus();
32753 wxPyEndAllowThreads(__tstate);
32754 if (PyErr_Occurred()) SWIG_fail;
32755 }
32756 resultobj = SWIG_Py_Void();
32757 return resultobj;
32758 fail:
32759 return NULL;
32760 }
32761
32762
32763 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32764 PyObject *resultobj = 0;
32765 wxWindow *arg1 = (wxWindow *) 0 ;
32766 void *argp1 = 0 ;
32767 int res1 = 0 ;
32768 PyObject *swig_obj[1] ;
32769
32770 if (!args) SWIG_fail;
32771 swig_obj[0] = args;
32772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32773 if (!SWIG_IsOK(res1)) {
32774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32775 }
32776 arg1 = reinterpret_cast< wxWindow * >(argp1);
32777 {
32778 PyThreadState* __tstate = wxPyBeginAllowThreads();
32779 (arg1)->SetFocusFromKbd();
32780 wxPyEndAllowThreads(__tstate);
32781 if (PyErr_Occurred()) SWIG_fail;
32782 }
32783 resultobj = SWIG_Py_Void();
32784 return resultobj;
32785 fail:
32786 return NULL;
32787 }
32788
32789
32790 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32791 PyObject *resultobj = 0;
32792 wxWindow *result = 0 ;
32793
32794 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32795 {
32796 if (!wxPyCheckForApp()) SWIG_fail;
32797 PyThreadState* __tstate = wxPyBeginAllowThreads();
32798 result = (wxWindow *)wxWindow::FindFocus();
32799 wxPyEndAllowThreads(__tstate);
32800 if (PyErr_Occurred()) SWIG_fail;
32801 }
32802 {
32803 resultobj = wxPyMake_wxObject(result, 0);
32804 }
32805 return resultobj;
32806 fail:
32807 return NULL;
32808 }
32809
32810
32811 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32812 PyObject *resultobj = 0;
32813 wxWindow *arg1 = (wxWindow *) 0 ;
32814 bool result;
32815 void *argp1 = 0 ;
32816 int res1 = 0 ;
32817 PyObject *swig_obj[1] ;
32818
32819 if (!args) SWIG_fail;
32820 swig_obj[0] = args;
32821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32822 if (!SWIG_IsOK(res1)) {
32823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32824 }
32825 arg1 = reinterpret_cast< wxWindow * >(argp1);
32826 {
32827 PyThreadState* __tstate = wxPyBeginAllowThreads();
32828 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32829 wxPyEndAllowThreads(__tstate);
32830 if (PyErr_Occurred()) SWIG_fail;
32831 }
32832 {
32833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32834 }
32835 return resultobj;
32836 fail:
32837 return NULL;
32838 }
32839
32840
32841 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32842 PyObject *resultobj = 0;
32843 wxWindow *arg1 = (wxWindow *) 0 ;
32844 bool result;
32845 void *argp1 = 0 ;
32846 int res1 = 0 ;
32847 PyObject *swig_obj[1] ;
32848
32849 if (!args) SWIG_fail;
32850 swig_obj[0] = args;
32851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32852 if (!SWIG_IsOK(res1)) {
32853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32854 }
32855 arg1 = reinterpret_cast< wxWindow * >(argp1);
32856 {
32857 PyThreadState* __tstate = wxPyBeginAllowThreads();
32858 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32859 wxPyEndAllowThreads(__tstate);
32860 if (PyErr_Occurred()) SWIG_fail;
32861 }
32862 {
32863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32864 }
32865 return resultobj;
32866 fail:
32867 return NULL;
32868 }
32869
32870
32871 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32872 PyObject *resultobj = 0;
32873 wxWindow *arg1 = (wxWindow *) 0 ;
32874 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32875 bool result;
32876 void *argp1 = 0 ;
32877 int res1 = 0 ;
32878 int val2 ;
32879 int ecode2 = 0 ;
32880 PyObject * obj0 = 0 ;
32881 PyObject * obj1 = 0 ;
32882 char * kwnames[] = {
32883 (char *) "self",(char *) "flags", NULL
32884 };
32885
32886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32888 if (!SWIG_IsOK(res1)) {
32889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32890 }
32891 arg1 = reinterpret_cast< wxWindow * >(argp1);
32892 if (obj1) {
32893 ecode2 = SWIG_AsVal_int(obj1, &val2);
32894 if (!SWIG_IsOK(ecode2)) {
32895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32896 }
32897 arg2 = static_cast< int >(val2);
32898 }
32899 {
32900 PyThreadState* __tstate = wxPyBeginAllowThreads();
32901 result = (bool)(arg1)->Navigate(arg2);
32902 wxPyEndAllowThreads(__tstate);
32903 if (PyErr_Occurred()) SWIG_fail;
32904 }
32905 {
32906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32907 }
32908 return resultobj;
32909 fail:
32910 return NULL;
32911 }
32912
32913
32914 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32915 PyObject *resultobj = 0;
32916 wxWindow *arg1 = (wxWindow *) 0 ;
32917 wxWindow *arg2 = (wxWindow *) 0 ;
32918 void *argp1 = 0 ;
32919 int res1 = 0 ;
32920 void *argp2 = 0 ;
32921 int res2 = 0 ;
32922 PyObject * obj0 = 0 ;
32923 PyObject * obj1 = 0 ;
32924 char * kwnames[] = {
32925 (char *) "self",(char *) "win", NULL
32926 };
32927
32928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32930 if (!SWIG_IsOK(res1)) {
32931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32932 }
32933 arg1 = reinterpret_cast< wxWindow * >(argp1);
32934 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32935 if (!SWIG_IsOK(res2)) {
32936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32937 }
32938 arg2 = reinterpret_cast< wxWindow * >(argp2);
32939 {
32940 PyThreadState* __tstate = wxPyBeginAllowThreads();
32941 (arg1)->MoveAfterInTabOrder(arg2);
32942 wxPyEndAllowThreads(__tstate);
32943 if (PyErr_Occurred()) SWIG_fail;
32944 }
32945 resultobj = SWIG_Py_Void();
32946 return resultobj;
32947 fail:
32948 return NULL;
32949 }
32950
32951
32952 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32953 PyObject *resultobj = 0;
32954 wxWindow *arg1 = (wxWindow *) 0 ;
32955 wxWindow *arg2 = (wxWindow *) 0 ;
32956 void *argp1 = 0 ;
32957 int res1 = 0 ;
32958 void *argp2 = 0 ;
32959 int res2 = 0 ;
32960 PyObject * obj0 = 0 ;
32961 PyObject * obj1 = 0 ;
32962 char * kwnames[] = {
32963 (char *) "self",(char *) "win", NULL
32964 };
32965
32966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32968 if (!SWIG_IsOK(res1)) {
32969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32970 }
32971 arg1 = reinterpret_cast< wxWindow * >(argp1);
32972 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32973 if (!SWIG_IsOK(res2)) {
32974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32975 }
32976 arg2 = reinterpret_cast< wxWindow * >(argp2);
32977 {
32978 PyThreadState* __tstate = wxPyBeginAllowThreads();
32979 (arg1)->MoveBeforeInTabOrder(arg2);
32980 wxPyEndAllowThreads(__tstate);
32981 if (PyErr_Occurred()) SWIG_fail;
32982 }
32983 resultobj = SWIG_Py_Void();
32984 return resultobj;
32985 fail:
32986 return NULL;
32987 }
32988
32989
32990 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32991 PyObject *resultobj = 0;
32992 wxWindow *arg1 = (wxWindow *) 0 ;
32993 PyObject *result = 0 ;
32994 void *argp1 = 0 ;
32995 int res1 = 0 ;
32996 PyObject *swig_obj[1] ;
32997
32998 if (!args) SWIG_fail;
32999 swig_obj[0] = args;
33000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33001 if (!SWIG_IsOK(res1)) {
33002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33003 }
33004 arg1 = reinterpret_cast< wxWindow * >(argp1);
33005 {
33006 PyThreadState* __tstate = wxPyBeginAllowThreads();
33007 result = (PyObject *)wxWindow_GetChildren(arg1);
33008 wxPyEndAllowThreads(__tstate);
33009 if (PyErr_Occurred()) SWIG_fail;
33010 }
33011 resultobj = result;
33012 return resultobj;
33013 fail:
33014 return NULL;
33015 }
33016
33017
33018 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33019 PyObject *resultobj = 0;
33020 wxWindow *arg1 = (wxWindow *) 0 ;
33021 wxWindow *result = 0 ;
33022 void *argp1 = 0 ;
33023 int res1 = 0 ;
33024 PyObject *swig_obj[1] ;
33025
33026 if (!args) SWIG_fail;
33027 swig_obj[0] = args;
33028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33029 if (!SWIG_IsOK(res1)) {
33030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33031 }
33032 arg1 = reinterpret_cast< wxWindow * >(argp1);
33033 {
33034 PyThreadState* __tstate = wxPyBeginAllowThreads();
33035 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33036 wxPyEndAllowThreads(__tstate);
33037 if (PyErr_Occurred()) SWIG_fail;
33038 }
33039 {
33040 resultobj = wxPyMake_wxObject(result, 0);
33041 }
33042 return resultobj;
33043 fail:
33044 return NULL;
33045 }
33046
33047
33048 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33049 PyObject *resultobj = 0;
33050 wxWindow *arg1 = (wxWindow *) 0 ;
33051 wxWindow *result = 0 ;
33052 void *argp1 = 0 ;
33053 int res1 = 0 ;
33054 PyObject *swig_obj[1] ;
33055
33056 if (!args) SWIG_fail;
33057 swig_obj[0] = args;
33058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33059 if (!SWIG_IsOK(res1)) {
33060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33061 }
33062 arg1 = reinterpret_cast< wxWindow * >(argp1);
33063 {
33064 PyThreadState* __tstate = wxPyBeginAllowThreads();
33065 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33066 wxPyEndAllowThreads(__tstate);
33067 if (PyErr_Occurred()) SWIG_fail;
33068 }
33069 {
33070 resultobj = wxPyMake_wxObject(result, 0);
33071 }
33072 return resultobj;
33073 fail:
33074 return NULL;
33075 }
33076
33077
33078 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33079 PyObject *resultobj = 0;
33080 wxWindow *arg1 = (wxWindow *) 0 ;
33081 bool result;
33082 void *argp1 = 0 ;
33083 int res1 = 0 ;
33084 PyObject *swig_obj[1] ;
33085
33086 if (!args) SWIG_fail;
33087 swig_obj[0] = args;
33088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33089 if (!SWIG_IsOK(res1)) {
33090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33091 }
33092 arg1 = reinterpret_cast< wxWindow * >(argp1);
33093 {
33094 PyThreadState* __tstate = wxPyBeginAllowThreads();
33095 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33096 wxPyEndAllowThreads(__tstate);
33097 if (PyErr_Occurred()) SWIG_fail;
33098 }
33099 {
33100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33101 }
33102 return resultobj;
33103 fail:
33104 return NULL;
33105 }
33106
33107
33108 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33109 PyObject *resultobj = 0;
33110 wxWindow *arg1 = (wxWindow *) 0 ;
33111 wxWindow *arg2 = (wxWindow *) 0 ;
33112 bool result;
33113 void *argp1 = 0 ;
33114 int res1 = 0 ;
33115 void *argp2 = 0 ;
33116 int res2 = 0 ;
33117 PyObject * obj0 = 0 ;
33118 PyObject * obj1 = 0 ;
33119 char * kwnames[] = {
33120 (char *) "self",(char *) "newParent", NULL
33121 };
33122
33123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33125 if (!SWIG_IsOK(res1)) {
33126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33127 }
33128 arg1 = reinterpret_cast< wxWindow * >(argp1);
33129 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33130 if (!SWIG_IsOK(res2)) {
33131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33132 }
33133 arg2 = reinterpret_cast< wxWindow * >(argp2);
33134 {
33135 PyThreadState* __tstate = wxPyBeginAllowThreads();
33136 result = (bool)(arg1)->Reparent(arg2);
33137 wxPyEndAllowThreads(__tstate);
33138 if (PyErr_Occurred()) SWIG_fail;
33139 }
33140 {
33141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33142 }
33143 return resultobj;
33144 fail:
33145 return NULL;
33146 }
33147
33148
33149 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33150 PyObject *resultobj = 0;
33151 wxWindow *arg1 = (wxWindow *) 0 ;
33152 wxWindow *arg2 = (wxWindow *) 0 ;
33153 void *argp1 = 0 ;
33154 int res1 = 0 ;
33155 void *argp2 = 0 ;
33156 int res2 = 0 ;
33157 PyObject * obj0 = 0 ;
33158 PyObject * obj1 = 0 ;
33159 char * kwnames[] = {
33160 (char *) "self",(char *) "child", NULL
33161 };
33162
33163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33165 if (!SWIG_IsOK(res1)) {
33166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33167 }
33168 arg1 = reinterpret_cast< wxWindow * >(argp1);
33169 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33170 if (!SWIG_IsOK(res2)) {
33171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33172 }
33173 arg2 = reinterpret_cast< wxWindow * >(argp2);
33174 {
33175 PyThreadState* __tstate = wxPyBeginAllowThreads();
33176 (arg1)->AddChild(arg2);
33177 wxPyEndAllowThreads(__tstate);
33178 if (PyErr_Occurred()) SWIG_fail;
33179 }
33180 resultobj = SWIG_Py_Void();
33181 return resultobj;
33182 fail:
33183 return NULL;
33184 }
33185
33186
33187 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33188 PyObject *resultobj = 0;
33189 wxWindow *arg1 = (wxWindow *) 0 ;
33190 wxWindow *arg2 = (wxWindow *) 0 ;
33191 void *argp1 = 0 ;
33192 int res1 = 0 ;
33193 void *argp2 = 0 ;
33194 int res2 = 0 ;
33195 PyObject * obj0 = 0 ;
33196 PyObject * obj1 = 0 ;
33197 char * kwnames[] = {
33198 (char *) "self",(char *) "child", NULL
33199 };
33200
33201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33203 if (!SWIG_IsOK(res1)) {
33204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33205 }
33206 arg1 = reinterpret_cast< wxWindow * >(argp1);
33207 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33208 if (!SWIG_IsOK(res2)) {
33209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33210 }
33211 arg2 = reinterpret_cast< wxWindow * >(argp2);
33212 {
33213 PyThreadState* __tstate = wxPyBeginAllowThreads();
33214 (arg1)->RemoveChild(arg2);
33215 wxPyEndAllowThreads(__tstate);
33216 if (PyErr_Occurred()) SWIG_fail;
33217 }
33218 resultobj = SWIG_Py_Void();
33219 return resultobj;
33220 fail:
33221 return NULL;
33222 }
33223
33224
33225 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33226 PyObject *resultobj = 0;
33227 wxWindow *arg1 = (wxWindow *) 0 ;
33228 bool arg2 ;
33229 void *argp1 = 0 ;
33230 int res1 = 0 ;
33231 bool val2 ;
33232 int ecode2 = 0 ;
33233 PyObject * obj0 = 0 ;
33234 PyObject * obj1 = 0 ;
33235 char * kwnames[] = {
33236 (char *) "self",(char *) "on", NULL
33237 };
33238
33239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33241 if (!SWIG_IsOK(res1)) {
33242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33243 }
33244 arg1 = reinterpret_cast< wxWindow * >(argp1);
33245 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33246 if (!SWIG_IsOK(ecode2)) {
33247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33248 }
33249 arg2 = static_cast< bool >(val2);
33250 {
33251 PyThreadState* __tstate = wxPyBeginAllowThreads();
33252 wxWindow_SetDoubleBuffered(arg1,arg2);
33253 wxPyEndAllowThreads(__tstate);
33254 if (PyErr_Occurred()) SWIG_fail;
33255 }
33256 resultobj = SWIG_Py_Void();
33257 return resultobj;
33258 fail:
33259 return NULL;
33260 }
33261
33262
33263 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33264 PyObject *resultobj = 0;
33265 wxWindow *arg1 = (wxWindow *) 0 ;
33266 long arg2 ;
33267 wxWindow *result = 0 ;
33268 void *argp1 = 0 ;
33269 int res1 = 0 ;
33270 long val2 ;
33271 int ecode2 = 0 ;
33272 PyObject * obj0 = 0 ;
33273 PyObject * obj1 = 0 ;
33274 char * kwnames[] = {
33275 (char *) "self",(char *) "winid", NULL
33276 };
33277
33278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33280 if (!SWIG_IsOK(res1)) {
33281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33282 }
33283 arg1 = reinterpret_cast< wxWindow * >(argp1);
33284 ecode2 = SWIG_AsVal_long(obj1, &val2);
33285 if (!SWIG_IsOK(ecode2)) {
33286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33287 }
33288 arg2 = static_cast< long >(val2);
33289 {
33290 PyThreadState* __tstate = wxPyBeginAllowThreads();
33291 result = (wxWindow *)(arg1)->FindWindow(arg2);
33292 wxPyEndAllowThreads(__tstate);
33293 if (PyErr_Occurred()) SWIG_fail;
33294 }
33295 {
33296 resultobj = wxPyMake_wxObject(result, 0);
33297 }
33298 return resultobj;
33299 fail:
33300 return NULL;
33301 }
33302
33303
33304 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33305 PyObject *resultobj = 0;
33306 wxWindow *arg1 = (wxWindow *) 0 ;
33307 wxString *arg2 = 0 ;
33308 wxWindow *result = 0 ;
33309 void *argp1 = 0 ;
33310 int res1 = 0 ;
33311 bool temp2 = false ;
33312 PyObject * obj0 = 0 ;
33313 PyObject * obj1 = 0 ;
33314 char * kwnames[] = {
33315 (char *) "self",(char *) "name", NULL
33316 };
33317
33318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33320 if (!SWIG_IsOK(res1)) {
33321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33322 }
33323 arg1 = reinterpret_cast< wxWindow * >(argp1);
33324 {
33325 arg2 = wxString_in_helper(obj1);
33326 if (arg2 == NULL) SWIG_fail;
33327 temp2 = true;
33328 }
33329 {
33330 PyThreadState* __tstate = wxPyBeginAllowThreads();
33331 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33332 wxPyEndAllowThreads(__tstate);
33333 if (PyErr_Occurred()) SWIG_fail;
33334 }
33335 {
33336 resultobj = wxPyMake_wxObject(result, 0);
33337 }
33338 {
33339 if (temp2)
33340 delete arg2;
33341 }
33342 return resultobj;
33343 fail:
33344 {
33345 if (temp2)
33346 delete arg2;
33347 }
33348 return NULL;
33349 }
33350
33351
33352 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33353 PyObject *resultobj = 0;
33354 wxWindow *arg1 = (wxWindow *) 0 ;
33355 wxEvtHandler *result = 0 ;
33356 void *argp1 = 0 ;
33357 int res1 = 0 ;
33358 PyObject *swig_obj[1] ;
33359
33360 if (!args) SWIG_fail;
33361 swig_obj[0] = args;
33362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33363 if (!SWIG_IsOK(res1)) {
33364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33365 }
33366 arg1 = reinterpret_cast< wxWindow * >(argp1);
33367 {
33368 PyThreadState* __tstate = wxPyBeginAllowThreads();
33369 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33370 wxPyEndAllowThreads(__tstate);
33371 if (PyErr_Occurred()) SWIG_fail;
33372 }
33373 {
33374 resultobj = wxPyMake_wxObject(result, 0);
33375 }
33376 return resultobj;
33377 fail:
33378 return NULL;
33379 }
33380
33381
33382 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33383 PyObject *resultobj = 0;
33384 wxWindow *arg1 = (wxWindow *) 0 ;
33385 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33386 void *argp1 = 0 ;
33387 int res1 = 0 ;
33388 void *argp2 = 0 ;
33389 int res2 = 0 ;
33390 PyObject * obj0 = 0 ;
33391 PyObject * obj1 = 0 ;
33392 char * kwnames[] = {
33393 (char *) "self",(char *) "handler", NULL
33394 };
33395
33396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33398 if (!SWIG_IsOK(res1)) {
33399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33400 }
33401 arg1 = reinterpret_cast< wxWindow * >(argp1);
33402 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33403 if (!SWIG_IsOK(res2)) {
33404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33405 }
33406 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33407 {
33408 PyThreadState* __tstate = wxPyBeginAllowThreads();
33409 (arg1)->SetEventHandler(arg2);
33410 wxPyEndAllowThreads(__tstate);
33411 if (PyErr_Occurred()) SWIG_fail;
33412 }
33413 resultobj = SWIG_Py_Void();
33414 return resultobj;
33415 fail:
33416 return NULL;
33417 }
33418
33419
33420 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33421 PyObject *resultobj = 0;
33422 wxWindow *arg1 = (wxWindow *) 0 ;
33423 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33424 void *argp1 = 0 ;
33425 int res1 = 0 ;
33426 void *argp2 = 0 ;
33427 int res2 = 0 ;
33428 PyObject * obj0 = 0 ;
33429 PyObject * obj1 = 0 ;
33430 char * kwnames[] = {
33431 (char *) "self",(char *) "handler", NULL
33432 };
33433
33434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33436 if (!SWIG_IsOK(res1)) {
33437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33438 }
33439 arg1 = reinterpret_cast< wxWindow * >(argp1);
33440 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33441 if (!SWIG_IsOK(res2)) {
33442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33443 }
33444 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33445 {
33446 PyThreadState* __tstate = wxPyBeginAllowThreads();
33447 (arg1)->PushEventHandler(arg2);
33448 wxPyEndAllowThreads(__tstate);
33449 if (PyErr_Occurred()) SWIG_fail;
33450 }
33451 resultobj = SWIG_Py_Void();
33452 return resultobj;
33453 fail:
33454 return NULL;
33455 }
33456
33457
33458 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33459 PyObject *resultobj = 0;
33460 wxWindow *arg1 = (wxWindow *) 0 ;
33461 bool arg2 = (bool) false ;
33462 wxEvtHandler *result = 0 ;
33463 void *argp1 = 0 ;
33464 int res1 = 0 ;
33465 bool val2 ;
33466 int ecode2 = 0 ;
33467 PyObject * obj0 = 0 ;
33468 PyObject * obj1 = 0 ;
33469 char * kwnames[] = {
33470 (char *) "self",(char *) "deleteHandler", NULL
33471 };
33472
33473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33475 if (!SWIG_IsOK(res1)) {
33476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33477 }
33478 arg1 = reinterpret_cast< wxWindow * >(argp1);
33479 if (obj1) {
33480 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33481 if (!SWIG_IsOK(ecode2)) {
33482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33483 }
33484 arg2 = static_cast< bool >(val2);
33485 }
33486 {
33487 PyThreadState* __tstate = wxPyBeginAllowThreads();
33488 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33489 wxPyEndAllowThreads(__tstate);
33490 if (PyErr_Occurred()) SWIG_fail;
33491 }
33492 {
33493 resultobj = wxPyMake_wxObject(result, 0);
33494 }
33495 return resultobj;
33496 fail:
33497 return NULL;
33498 }
33499
33500
33501 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33502 PyObject *resultobj = 0;
33503 wxWindow *arg1 = (wxWindow *) 0 ;
33504 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33505 bool result;
33506 void *argp1 = 0 ;
33507 int res1 = 0 ;
33508 void *argp2 = 0 ;
33509 int res2 = 0 ;
33510 PyObject * obj0 = 0 ;
33511 PyObject * obj1 = 0 ;
33512 char * kwnames[] = {
33513 (char *) "self",(char *) "handler", NULL
33514 };
33515
33516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33518 if (!SWIG_IsOK(res1)) {
33519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33520 }
33521 arg1 = reinterpret_cast< wxWindow * >(argp1);
33522 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33523 if (!SWIG_IsOK(res2)) {
33524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33525 }
33526 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33527 {
33528 PyThreadState* __tstate = wxPyBeginAllowThreads();
33529 result = (bool)(arg1)->RemoveEventHandler(arg2);
33530 wxPyEndAllowThreads(__tstate);
33531 if (PyErr_Occurred()) SWIG_fail;
33532 }
33533 {
33534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33535 }
33536 return resultobj;
33537 fail:
33538 return NULL;
33539 }
33540
33541
33542 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33543 PyObject *resultobj = 0;
33544 wxWindow *arg1 = (wxWindow *) 0 ;
33545 wxValidator *arg2 = 0 ;
33546 void *argp1 = 0 ;
33547 int res1 = 0 ;
33548 void *argp2 = 0 ;
33549 int res2 = 0 ;
33550 PyObject * obj0 = 0 ;
33551 PyObject * obj1 = 0 ;
33552 char * kwnames[] = {
33553 (char *) "self",(char *) "validator", NULL
33554 };
33555
33556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33558 if (!SWIG_IsOK(res1)) {
33559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33560 }
33561 arg1 = reinterpret_cast< wxWindow * >(argp1);
33562 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33563 if (!SWIG_IsOK(res2)) {
33564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33565 }
33566 if (!argp2) {
33567 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33568 }
33569 arg2 = reinterpret_cast< wxValidator * >(argp2);
33570 {
33571 PyThreadState* __tstate = wxPyBeginAllowThreads();
33572 (arg1)->SetValidator((wxValidator const &)*arg2);
33573 wxPyEndAllowThreads(__tstate);
33574 if (PyErr_Occurred()) SWIG_fail;
33575 }
33576 resultobj = SWIG_Py_Void();
33577 return resultobj;
33578 fail:
33579 return NULL;
33580 }
33581
33582
33583 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33584 PyObject *resultobj = 0;
33585 wxWindow *arg1 = (wxWindow *) 0 ;
33586 wxValidator *result = 0 ;
33587 void *argp1 = 0 ;
33588 int res1 = 0 ;
33589 PyObject *swig_obj[1] ;
33590
33591 if (!args) SWIG_fail;
33592 swig_obj[0] = args;
33593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33594 if (!SWIG_IsOK(res1)) {
33595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33596 }
33597 arg1 = reinterpret_cast< wxWindow * >(argp1);
33598 {
33599 PyThreadState* __tstate = wxPyBeginAllowThreads();
33600 result = (wxValidator *)(arg1)->GetValidator();
33601 wxPyEndAllowThreads(__tstate);
33602 if (PyErr_Occurred()) SWIG_fail;
33603 }
33604 {
33605 resultobj = wxPyMake_wxObject(result, (bool)0);
33606 }
33607 return resultobj;
33608 fail:
33609 return NULL;
33610 }
33611
33612
33613 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33614 PyObject *resultobj = 0;
33615 wxWindow *arg1 = (wxWindow *) 0 ;
33616 bool result;
33617 void *argp1 = 0 ;
33618 int res1 = 0 ;
33619 PyObject *swig_obj[1] ;
33620
33621 if (!args) SWIG_fail;
33622 swig_obj[0] = args;
33623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33624 if (!SWIG_IsOK(res1)) {
33625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33626 }
33627 arg1 = reinterpret_cast< wxWindow * >(argp1);
33628 {
33629 PyThreadState* __tstate = wxPyBeginAllowThreads();
33630 result = (bool)(arg1)->Validate();
33631 wxPyEndAllowThreads(__tstate);
33632 if (PyErr_Occurred()) SWIG_fail;
33633 }
33634 {
33635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33636 }
33637 return resultobj;
33638 fail:
33639 return NULL;
33640 }
33641
33642
33643 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33644 PyObject *resultobj = 0;
33645 wxWindow *arg1 = (wxWindow *) 0 ;
33646 bool result;
33647 void *argp1 = 0 ;
33648 int res1 = 0 ;
33649 PyObject *swig_obj[1] ;
33650
33651 if (!args) SWIG_fail;
33652 swig_obj[0] = args;
33653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33654 if (!SWIG_IsOK(res1)) {
33655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33656 }
33657 arg1 = reinterpret_cast< wxWindow * >(argp1);
33658 {
33659 PyThreadState* __tstate = wxPyBeginAllowThreads();
33660 result = (bool)(arg1)->TransferDataToWindow();
33661 wxPyEndAllowThreads(__tstate);
33662 if (PyErr_Occurred()) SWIG_fail;
33663 }
33664 {
33665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33666 }
33667 return resultobj;
33668 fail:
33669 return NULL;
33670 }
33671
33672
33673 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33674 PyObject *resultobj = 0;
33675 wxWindow *arg1 = (wxWindow *) 0 ;
33676 bool result;
33677 void *argp1 = 0 ;
33678 int res1 = 0 ;
33679 PyObject *swig_obj[1] ;
33680
33681 if (!args) SWIG_fail;
33682 swig_obj[0] = args;
33683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33684 if (!SWIG_IsOK(res1)) {
33685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33686 }
33687 arg1 = reinterpret_cast< wxWindow * >(argp1);
33688 {
33689 PyThreadState* __tstate = wxPyBeginAllowThreads();
33690 result = (bool)(arg1)->TransferDataFromWindow();
33691 wxPyEndAllowThreads(__tstate);
33692 if (PyErr_Occurred()) SWIG_fail;
33693 }
33694 {
33695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33696 }
33697 return resultobj;
33698 fail:
33699 return NULL;
33700 }
33701
33702
33703 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33704 PyObject *resultobj = 0;
33705 wxWindow *arg1 = (wxWindow *) 0 ;
33706 void *argp1 = 0 ;
33707 int res1 = 0 ;
33708 PyObject *swig_obj[1] ;
33709
33710 if (!args) SWIG_fail;
33711 swig_obj[0] = args;
33712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33713 if (!SWIG_IsOK(res1)) {
33714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33715 }
33716 arg1 = reinterpret_cast< wxWindow * >(argp1);
33717 {
33718 PyThreadState* __tstate = wxPyBeginAllowThreads();
33719 (arg1)->InitDialog();
33720 wxPyEndAllowThreads(__tstate);
33721 if (PyErr_Occurred()) SWIG_fail;
33722 }
33723 resultobj = SWIG_Py_Void();
33724 return resultobj;
33725 fail:
33726 return NULL;
33727 }
33728
33729
33730 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33731 PyObject *resultobj = 0;
33732 wxWindow *arg1 = (wxWindow *) 0 ;
33733 wxAcceleratorTable *arg2 = 0 ;
33734 void *argp1 = 0 ;
33735 int res1 = 0 ;
33736 void *argp2 = 0 ;
33737 int res2 = 0 ;
33738 PyObject * obj0 = 0 ;
33739 PyObject * obj1 = 0 ;
33740 char * kwnames[] = {
33741 (char *) "self",(char *) "accel", NULL
33742 };
33743
33744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33746 if (!SWIG_IsOK(res1)) {
33747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33748 }
33749 arg1 = reinterpret_cast< wxWindow * >(argp1);
33750 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33751 if (!SWIG_IsOK(res2)) {
33752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33753 }
33754 if (!argp2) {
33755 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33756 }
33757 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33758 {
33759 PyThreadState* __tstate = wxPyBeginAllowThreads();
33760 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33761 wxPyEndAllowThreads(__tstate);
33762 if (PyErr_Occurred()) SWIG_fail;
33763 }
33764 resultobj = SWIG_Py_Void();
33765 return resultobj;
33766 fail:
33767 return NULL;
33768 }
33769
33770
33771 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33772 PyObject *resultobj = 0;
33773 wxWindow *arg1 = (wxWindow *) 0 ;
33774 wxAcceleratorTable *result = 0 ;
33775 void *argp1 = 0 ;
33776 int res1 = 0 ;
33777 PyObject *swig_obj[1] ;
33778
33779 if (!args) SWIG_fail;
33780 swig_obj[0] = args;
33781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33782 if (!SWIG_IsOK(res1)) {
33783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33784 }
33785 arg1 = reinterpret_cast< wxWindow * >(argp1);
33786 {
33787 PyThreadState* __tstate = wxPyBeginAllowThreads();
33788 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33789 wxPyEndAllowThreads(__tstate);
33790 if (PyErr_Occurred()) SWIG_fail;
33791 }
33792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33793 return resultobj;
33794 fail:
33795 return NULL;
33796 }
33797
33798
33799 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33800 PyObject *resultobj = 0;
33801 wxWindow *arg1 = (wxWindow *) 0 ;
33802 int arg2 ;
33803 int arg3 ;
33804 int arg4 ;
33805 bool result;
33806 void *argp1 = 0 ;
33807 int res1 = 0 ;
33808 int val2 ;
33809 int ecode2 = 0 ;
33810 int val3 ;
33811 int ecode3 = 0 ;
33812 int val4 ;
33813 int ecode4 = 0 ;
33814 PyObject * obj0 = 0 ;
33815 PyObject * obj1 = 0 ;
33816 PyObject * obj2 = 0 ;
33817 PyObject * obj3 = 0 ;
33818 char * kwnames[] = {
33819 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33820 };
33821
33822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33824 if (!SWIG_IsOK(res1)) {
33825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33826 }
33827 arg1 = reinterpret_cast< wxWindow * >(argp1);
33828 ecode2 = SWIG_AsVal_int(obj1, &val2);
33829 if (!SWIG_IsOK(ecode2)) {
33830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33831 }
33832 arg2 = static_cast< int >(val2);
33833 ecode3 = SWIG_AsVal_int(obj2, &val3);
33834 if (!SWIG_IsOK(ecode3)) {
33835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33836 }
33837 arg3 = static_cast< int >(val3);
33838 ecode4 = SWIG_AsVal_int(obj3, &val4);
33839 if (!SWIG_IsOK(ecode4)) {
33840 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33841 }
33842 arg4 = static_cast< int >(val4);
33843 {
33844 PyThreadState* __tstate = wxPyBeginAllowThreads();
33845 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33846 wxPyEndAllowThreads(__tstate);
33847 if (PyErr_Occurred()) SWIG_fail;
33848 }
33849 {
33850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33851 }
33852 return resultobj;
33853 fail:
33854 return NULL;
33855 }
33856
33857
33858 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33859 PyObject *resultobj = 0;
33860 wxWindow *arg1 = (wxWindow *) 0 ;
33861 int arg2 ;
33862 bool result;
33863 void *argp1 = 0 ;
33864 int res1 = 0 ;
33865 int val2 ;
33866 int ecode2 = 0 ;
33867 PyObject * obj0 = 0 ;
33868 PyObject * obj1 = 0 ;
33869 char * kwnames[] = {
33870 (char *) "self",(char *) "hotkeyId", NULL
33871 };
33872
33873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33875 if (!SWIG_IsOK(res1)) {
33876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33877 }
33878 arg1 = reinterpret_cast< wxWindow * >(argp1);
33879 ecode2 = SWIG_AsVal_int(obj1, &val2);
33880 if (!SWIG_IsOK(ecode2)) {
33881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33882 }
33883 arg2 = static_cast< int >(val2);
33884 {
33885 PyThreadState* __tstate = wxPyBeginAllowThreads();
33886 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33887 wxPyEndAllowThreads(__tstate);
33888 if (PyErr_Occurred()) SWIG_fail;
33889 }
33890 {
33891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33892 }
33893 return resultobj;
33894 fail:
33895 return NULL;
33896 }
33897
33898
33899 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33900 PyObject *resultobj = 0;
33901 wxWindow *arg1 = (wxWindow *) 0 ;
33902 wxPoint *arg2 = 0 ;
33903 wxPoint result;
33904 void *argp1 = 0 ;
33905 int res1 = 0 ;
33906 wxPoint temp2 ;
33907 PyObject * obj0 = 0 ;
33908 PyObject * obj1 = 0 ;
33909 char * kwnames[] = {
33910 (char *) "self",(char *) "pt", NULL
33911 };
33912
33913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33915 if (!SWIG_IsOK(res1)) {
33916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33917 }
33918 arg1 = reinterpret_cast< wxWindow * >(argp1);
33919 {
33920 arg2 = &temp2;
33921 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33922 }
33923 {
33924 PyThreadState* __tstate = wxPyBeginAllowThreads();
33925 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33926 wxPyEndAllowThreads(__tstate);
33927 if (PyErr_Occurred()) SWIG_fail;
33928 }
33929 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33930 return resultobj;
33931 fail:
33932 return NULL;
33933 }
33934
33935
33936 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33937 PyObject *resultobj = 0;
33938 wxWindow *arg1 = (wxWindow *) 0 ;
33939 wxSize *arg2 = 0 ;
33940 wxSize result;
33941 void *argp1 = 0 ;
33942 int res1 = 0 ;
33943 wxSize temp2 ;
33944 PyObject * obj0 = 0 ;
33945 PyObject * obj1 = 0 ;
33946 char * kwnames[] = {
33947 (char *) "self",(char *) "sz", NULL
33948 };
33949
33950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33952 if (!SWIG_IsOK(res1)) {
33953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33954 }
33955 arg1 = reinterpret_cast< wxWindow * >(argp1);
33956 {
33957 arg2 = &temp2;
33958 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33959 }
33960 {
33961 PyThreadState* __tstate = wxPyBeginAllowThreads();
33962 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33963 wxPyEndAllowThreads(__tstate);
33964 if (PyErr_Occurred()) SWIG_fail;
33965 }
33966 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33967 return resultobj;
33968 fail:
33969 return NULL;
33970 }
33971
33972
33973 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33974 PyObject *resultobj = 0;
33975 wxWindow *arg1 = (wxWindow *) 0 ;
33976 wxPoint *arg2 = 0 ;
33977 wxPoint result;
33978 void *argp1 = 0 ;
33979 int res1 = 0 ;
33980 wxPoint temp2 ;
33981 PyObject * obj0 = 0 ;
33982 PyObject * obj1 = 0 ;
33983 char * kwnames[] = {
33984 (char *) "self",(char *) "pt", NULL
33985 };
33986
33987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33989 if (!SWIG_IsOK(res1)) {
33990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33991 }
33992 arg1 = reinterpret_cast< wxWindow * >(argp1);
33993 {
33994 arg2 = &temp2;
33995 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33996 }
33997 {
33998 PyThreadState* __tstate = wxPyBeginAllowThreads();
33999 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34000 wxPyEndAllowThreads(__tstate);
34001 if (PyErr_Occurred()) SWIG_fail;
34002 }
34003 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34004 return resultobj;
34005 fail:
34006 return NULL;
34007 }
34008
34009
34010 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34011 PyObject *resultobj = 0;
34012 wxWindow *arg1 = (wxWindow *) 0 ;
34013 wxSize *arg2 = 0 ;
34014 wxSize result;
34015 void *argp1 = 0 ;
34016 int res1 = 0 ;
34017 wxSize temp2 ;
34018 PyObject * obj0 = 0 ;
34019 PyObject * obj1 = 0 ;
34020 char * kwnames[] = {
34021 (char *) "self",(char *) "sz", NULL
34022 };
34023
34024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34026 if (!SWIG_IsOK(res1)) {
34027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34028 }
34029 arg1 = reinterpret_cast< wxWindow * >(argp1);
34030 {
34031 arg2 = &temp2;
34032 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34033 }
34034 {
34035 PyThreadState* __tstate = wxPyBeginAllowThreads();
34036 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34037 wxPyEndAllowThreads(__tstate);
34038 if (PyErr_Occurred()) SWIG_fail;
34039 }
34040 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34041 return resultobj;
34042 fail:
34043 return NULL;
34044 }
34045
34046
34047 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34048 PyObject *resultobj = 0;
34049 wxWindow *arg1 = (wxWindow *) 0 ;
34050 wxPoint *arg2 = 0 ;
34051 wxPoint result;
34052 void *argp1 = 0 ;
34053 int res1 = 0 ;
34054 wxPoint temp2 ;
34055 PyObject * obj0 = 0 ;
34056 PyObject * obj1 = 0 ;
34057 char * kwnames[] = {
34058 (char *) "self",(char *) "pt", NULL
34059 };
34060
34061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34063 if (!SWIG_IsOK(res1)) {
34064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34065 }
34066 arg1 = reinterpret_cast< wxWindow * >(argp1);
34067 {
34068 arg2 = &temp2;
34069 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34070 }
34071 {
34072 PyThreadState* __tstate = wxPyBeginAllowThreads();
34073 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34074 wxPyEndAllowThreads(__tstate);
34075 if (PyErr_Occurred()) SWIG_fail;
34076 }
34077 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34078 return resultobj;
34079 fail:
34080 return NULL;
34081 }
34082
34083
34084 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34085 PyObject *resultobj = 0;
34086 wxWindow *arg1 = (wxWindow *) 0 ;
34087 wxSize *arg2 = 0 ;
34088 wxSize result;
34089 void *argp1 = 0 ;
34090 int res1 = 0 ;
34091 wxSize temp2 ;
34092 PyObject * obj0 = 0 ;
34093 PyObject * obj1 = 0 ;
34094 char * kwnames[] = {
34095 (char *) "self",(char *) "sz", NULL
34096 };
34097
34098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34100 if (!SWIG_IsOK(res1)) {
34101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34102 }
34103 arg1 = reinterpret_cast< wxWindow * >(argp1);
34104 {
34105 arg2 = &temp2;
34106 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34107 }
34108 {
34109 PyThreadState* __tstate = wxPyBeginAllowThreads();
34110 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34111 wxPyEndAllowThreads(__tstate);
34112 if (PyErr_Occurred()) SWIG_fail;
34113 }
34114 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34115 return resultobj;
34116 fail:
34117 return NULL;
34118 }
34119
34120
34121 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34122 PyObject *resultobj = 0;
34123 wxWindow *arg1 = (wxWindow *) 0 ;
34124 int arg2 ;
34125 int arg3 ;
34126 void *argp1 = 0 ;
34127 int res1 = 0 ;
34128 int val2 ;
34129 int ecode2 = 0 ;
34130 int val3 ;
34131 int ecode3 = 0 ;
34132 PyObject * obj0 = 0 ;
34133 PyObject * obj1 = 0 ;
34134 PyObject * obj2 = 0 ;
34135 char * kwnames[] = {
34136 (char *) "self",(char *) "x",(char *) "y", NULL
34137 };
34138
34139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34141 if (!SWIG_IsOK(res1)) {
34142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34143 }
34144 arg1 = reinterpret_cast< wxWindow * >(argp1);
34145 ecode2 = SWIG_AsVal_int(obj1, &val2);
34146 if (!SWIG_IsOK(ecode2)) {
34147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34148 }
34149 arg2 = static_cast< int >(val2);
34150 ecode3 = SWIG_AsVal_int(obj2, &val3);
34151 if (!SWIG_IsOK(ecode3)) {
34152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34153 }
34154 arg3 = static_cast< int >(val3);
34155 {
34156 PyThreadState* __tstate = wxPyBeginAllowThreads();
34157 (arg1)->WarpPointer(arg2,arg3);
34158 wxPyEndAllowThreads(__tstate);
34159 if (PyErr_Occurred()) SWIG_fail;
34160 }
34161 resultobj = SWIG_Py_Void();
34162 return resultobj;
34163 fail:
34164 return NULL;
34165 }
34166
34167
34168 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34169 PyObject *resultobj = 0;
34170 wxWindow *arg1 = (wxWindow *) 0 ;
34171 void *argp1 = 0 ;
34172 int res1 = 0 ;
34173 PyObject *swig_obj[1] ;
34174
34175 if (!args) SWIG_fail;
34176 swig_obj[0] = args;
34177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34178 if (!SWIG_IsOK(res1)) {
34179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34180 }
34181 arg1 = reinterpret_cast< wxWindow * >(argp1);
34182 {
34183 PyThreadState* __tstate = wxPyBeginAllowThreads();
34184 (arg1)->CaptureMouse();
34185 wxPyEndAllowThreads(__tstate);
34186 if (PyErr_Occurred()) SWIG_fail;
34187 }
34188 resultobj = SWIG_Py_Void();
34189 return resultobj;
34190 fail:
34191 return NULL;
34192 }
34193
34194
34195 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34196 PyObject *resultobj = 0;
34197 wxWindow *arg1 = (wxWindow *) 0 ;
34198 void *argp1 = 0 ;
34199 int res1 = 0 ;
34200 PyObject *swig_obj[1] ;
34201
34202 if (!args) SWIG_fail;
34203 swig_obj[0] = args;
34204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34205 if (!SWIG_IsOK(res1)) {
34206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34207 }
34208 arg1 = reinterpret_cast< wxWindow * >(argp1);
34209 {
34210 PyThreadState* __tstate = wxPyBeginAllowThreads();
34211 (arg1)->ReleaseMouse();
34212 wxPyEndAllowThreads(__tstate);
34213 if (PyErr_Occurred()) SWIG_fail;
34214 }
34215 resultobj = SWIG_Py_Void();
34216 return resultobj;
34217 fail:
34218 return NULL;
34219 }
34220
34221
34222 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34223 PyObject *resultobj = 0;
34224 wxWindow *result = 0 ;
34225
34226 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34227 {
34228 if (!wxPyCheckForApp()) SWIG_fail;
34229 PyThreadState* __tstate = wxPyBeginAllowThreads();
34230 result = (wxWindow *)wxWindow::GetCapture();
34231 wxPyEndAllowThreads(__tstate);
34232 if (PyErr_Occurred()) SWIG_fail;
34233 }
34234 {
34235 resultobj = wxPyMake_wxObject(result, 0);
34236 }
34237 return resultobj;
34238 fail:
34239 return NULL;
34240 }
34241
34242
34243 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34244 PyObject *resultobj = 0;
34245 wxWindow *arg1 = (wxWindow *) 0 ;
34246 bool result;
34247 void *argp1 = 0 ;
34248 int res1 = 0 ;
34249 PyObject *swig_obj[1] ;
34250
34251 if (!args) SWIG_fail;
34252 swig_obj[0] = args;
34253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34254 if (!SWIG_IsOK(res1)) {
34255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34256 }
34257 arg1 = reinterpret_cast< wxWindow * >(argp1);
34258 {
34259 PyThreadState* __tstate = wxPyBeginAllowThreads();
34260 result = (bool)((wxWindow const *)arg1)->HasCapture();
34261 wxPyEndAllowThreads(__tstate);
34262 if (PyErr_Occurred()) SWIG_fail;
34263 }
34264 {
34265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34266 }
34267 return resultobj;
34268 fail:
34269 return NULL;
34270 }
34271
34272
34273 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34274 PyObject *resultobj = 0;
34275 wxWindow *arg1 = (wxWindow *) 0 ;
34276 bool arg2 = (bool) true ;
34277 wxRect *arg3 = (wxRect *) NULL ;
34278 void *argp1 = 0 ;
34279 int res1 = 0 ;
34280 bool val2 ;
34281 int ecode2 = 0 ;
34282 void *argp3 = 0 ;
34283 int res3 = 0 ;
34284 PyObject * obj0 = 0 ;
34285 PyObject * obj1 = 0 ;
34286 PyObject * obj2 = 0 ;
34287 char * kwnames[] = {
34288 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34289 };
34290
34291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34293 if (!SWIG_IsOK(res1)) {
34294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34295 }
34296 arg1 = reinterpret_cast< wxWindow * >(argp1);
34297 if (obj1) {
34298 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34299 if (!SWIG_IsOK(ecode2)) {
34300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34301 }
34302 arg2 = static_cast< bool >(val2);
34303 }
34304 if (obj2) {
34305 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34306 if (!SWIG_IsOK(res3)) {
34307 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34308 }
34309 arg3 = reinterpret_cast< wxRect * >(argp3);
34310 }
34311 {
34312 PyThreadState* __tstate = wxPyBeginAllowThreads();
34313 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34314 wxPyEndAllowThreads(__tstate);
34315 if (PyErr_Occurred()) SWIG_fail;
34316 }
34317 resultobj = SWIG_Py_Void();
34318 return resultobj;
34319 fail:
34320 return NULL;
34321 }
34322
34323
34324 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34325 PyObject *resultobj = 0;
34326 wxWindow *arg1 = (wxWindow *) 0 ;
34327 wxRect *arg2 = 0 ;
34328 bool arg3 = (bool) true ;
34329 void *argp1 = 0 ;
34330 int res1 = 0 ;
34331 wxRect temp2 ;
34332 bool val3 ;
34333 int ecode3 = 0 ;
34334 PyObject * obj0 = 0 ;
34335 PyObject * obj1 = 0 ;
34336 PyObject * obj2 = 0 ;
34337 char * kwnames[] = {
34338 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34339 };
34340
34341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34343 if (!SWIG_IsOK(res1)) {
34344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34345 }
34346 arg1 = reinterpret_cast< wxWindow * >(argp1);
34347 {
34348 arg2 = &temp2;
34349 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34350 }
34351 if (obj2) {
34352 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34353 if (!SWIG_IsOK(ecode3)) {
34354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34355 }
34356 arg3 = static_cast< bool >(val3);
34357 }
34358 {
34359 PyThreadState* __tstate = wxPyBeginAllowThreads();
34360 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34361 wxPyEndAllowThreads(__tstate);
34362 if (PyErr_Occurred()) SWIG_fail;
34363 }
34364 resultobj = SWIG_Py_Void();
34365 return resultobj;
34366 fail:
34367 return NULL;
34368 }
34369
34370
34371 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34372 PyObject *resultobj = 0;
34373 wxWindow *arg1 = (wxWindow *) 0 ;
34374 void *argp1 = 0 ;
34375 int res1 = 0 ;
34376 PyObject *swig_obj[1] ;
34377
34378 if (!args) SWIG_fail;
34379 swig_obj[0] = args;
34380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34381 if (!SWIG_IsOK(res1)) {
34382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34383 }
34384 arg1 = reinterpret_cast< wxWindow * >(argp1);
34385 {
34386 PyThreadState* __tstate = wxPyBeginAllowThreads();
34387 (arg1)->Update();
34388 wxPyEndAllowThreads(__tstate);
34389 if (PyErr_Occurred()) SWIG_fail;
34390 }
34391 resultobj = SWIG_Py_Void();
34392 return resultobj;
34393 fail:
34394 return NULL;
34395 }
34396
34397
34398 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34399 PyObject *resultobj = 0;
34400 wxWindow *arg1 = (wxWindow *) 0 ;
34401 void *argp1 = 0 ;
34402 int res1 = 0 ;
34403 PyObject *swig_obj[1] ;
34404
34405 if (!args) SWIG_fail;
34406 swig_obj[0] = args;
34407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34408 if (!SWIG_IsOK(res1)) {
34409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34410 }
34411 arg1 = reinterpret_cast< wxWindow * >(argp1);
34412 {
34413 PyThreadState* __tstate = wxPyBeginAllowThreads();
34414 (arg1)->ClearBackground();
34415 wxPyEndAllowThreads(__tstate);
34416 if (PyErr_Occurred()) SWIG_fail;
34417 }
34418 resultobj = SWIG_Py_Void();
34419 return resultobj;
34420 fail:
34421 return NULL;
34422 }
34423
34424
34425 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34426 PyObject *resultobj = 0;
34427 wxWindow *arg1 = (wxWindow *) 0 ;
34428 void *argp1 = 0 ;
34429 int res1 = 0 ;
34430 PyObject *swig_obj[1] ;
34431
34432 if (!args) SWIG_fail;
34433 swig_obj[0] = args;
34434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34435 if (!SWIG_IsOK(res1)) {
34436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34437 }
34438 arg1 = reinterpret_cast< wxWindow * >(argp1);
34439 {
34440 PyThreadState* __tstate = wxPyBeginAllowThreads();
34441 (arg1)->Freeze();
34442 wxPyEndAllowThreads(__tstate);
34443 if (PyErr_Occurred()) SWIG_fail;
34444 }
34445 resultobj = SWIG_Py_Void();
34446 return resultobj;
34447 fail:
34448 return NULL;
34449 }
34450
34451
34452 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34453 PyObject *resultobj = 0;
34454 wxWindow *arg1 = (wxWindow *) 0 ;
34455 void *argp1 = 0 ;
34456 int res1 = 0 ;
34457 PyObject *swig_obj[1] ;
34458
34459 if (!args) SWIG_fail;
34460 swig_obj[0] = args;
34461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34462 if (!SWIG_IsOK(res1)) {
34463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34464 }
34465 arg1 = reinterpret_cast< wxWindow * >(argp1);
34466 {
34467 PyThreadState* __tstate = wxPyBeginAllowThreads();
34468 (arg1)->Thaw();
34469 wxPyEndAllowThreads(__tstate);
34470 if (PyErr_Occurred()) SWIG_fail;
34471 }
34472 resultobj = SWIG_Py_Void();
34473 return resultobj;
34474 fail:
34475 return NULL;
34476 }
34477
34478
34479 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34480 PyObject *resultobj = 0;
34481 wxWindow *arg1 = (wxWindow *) 0 ;
34482 wxDC *arg2 = 0 ;
34483 void *argp1 = 0 ;
34484 int res1 = 0 ;
34485 void *argp2 = 0 ;
34486 int res2 = 0 ;
34487 PyObject * obj0 = 0 ;
34488 PyObject * obj1 = 0 ;
34489 char * kwnames[] = {
34490 (char *) "self",(char *) "dc", NULL
34491 };
34492
34493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34495 if (!SWIG_IsOK(res1)) {
34496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34497 }
34498 arg1 = reinterpret_cast< wxWindow * >(argp1);
34499 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34500 if (!SWIG_IsOK(res2)) {
34501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34502 }
34503 if (!argp2) {
34504 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34505 }
34506 arg2 = reinterpret_cast< wxDC * >(argp2);
34507 {
34508 PyThreadState* __tstate = wxPyBeginAllowThreads();
34509 (arg1)->PrepareDC(*arg2);
34510 wxPyEndAllowThreads(__tstate);
34511 if (PyErr_Occurred()) SWIG_fail;
34512 }
34513 resultobj = SWIG_Py_Void();
34514 return resultobj;
34515 fail:
34516 return NULL;
34517 }
34518
34519
34520 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34521 PyObject *resultobj = 0;
34522 wxWindow *arg1 = (wxWindow *) 0 ;
34523 wxRegion *result = 0 ;
34524 void *argp1 = 0 ;
34525 int res1 = 0 ;
34526 PyObject *swig_obj[1] ;
34527
34528 if (!args) SWIG_fail;
34529 swig_obj[0] = args;
34530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34531 if (!SWIG_IsOK(res1)) {
34532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34533 }
34534 arg1 = reinterpret_cast< wxWindow * >(argp1);
34535 {
34536 PyThreadState* __tstate = wxPyBeginAllowThreads();
34537 {
34538 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34539 result = (wxRegion *) &_result_ref;
34540 }
34541 wxPyEndAllowThreads(__tstate);
34542 if (PyErr_Occurred()) SWIG_fail;
34543 }
34544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34545 return resultobj;
34546 fail:
34547 return NULL;
34548 }
34549
34550
34551 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34552 PyObject *resultobj = 0;
34553 wxWindow *arg1 = (wxWindow *) 0 ;
34554 wxRect result;
34555 void *argp1 = 0 ;
34556 int res1 = 0 ;
34557 PyObject *swig_obj[1] ;
34558
34559 if (!args) SWIG_fail;
34560 swig_obj[0] = args;
34561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34562 if (!SWIG_IsOK(res1)) {
34563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34564 }
34565 arg1 = reinterpret_cast< wxWindow * >(argp1);
34566 {
34567 PyThreadState* __tstate = wxPyBeginAllowThreads();
34568 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34569 wxPyEndAllowThreads(__tstate);
34570 if (PyErr_Occurred()) SWIG_fail;
34571 }
34572 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34573 return resultobj;
34574 fail:
34575 return NULL;
34576 }
34577
34578
34579 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34580 PyObject *resultobj = 0;
34581 wxWindow *arg1 = (wxWindow *) 0 ;
34582 int arg2 ;
34583 int arg3 ;
34584 int arg4 = (int) 1 ;
34585 int arg5 = (int) 1 ;
34586 bool result;
34587 void *argp1 = 0 ;
34588 int res1 = 0 ;
34589 int val2 ;
34590 int ecode2 = 0 ;
34591 int val3 ;
34592 int ecode3 = 0 ;
34593 int val4 ;
34594 int ecode4 = 0 ;
34595 int val5 ;
34596 int ecode5 = 0 ;
34597 PyObject * obj0 = 0 ;
34598 PyObject * obj1 = 0 ;
34599 PyObject * obj2 = 0 ;
34600 PyObject * obj3 = 0 ;
34601 PyObject * obj4 = 0 ;
34602 char * kwnames[] = {
34603 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34604 };
34605
34606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34608 if (!SWIG_IsOK(res1)) {
34609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34610 }
34611 arg1 = reinterpret_cast< wxWindow * >(argp1);
34612 ecode2 = SWIG_AsVal_int(obj1, &val2);
34613 if (!SWIG_IsOK(ecode2)) {
34614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34615 }
34616 arg2 = static_cast< int >(val2);
34617 ecode3 = SWIG_AsVal_int(obj2, &val3);
34618 if (!SWIG_IsOK(ecode3)) {
34619 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34620 }
34621 arg3 = static_cast< int >(val3);
34622 if (obj3) {
34623 ecode4 = SWIG_AsVal_int(obj3, &val4);
34624 if (!SWIG_IsOK(ecode4)) {
34625 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34626 }
34627 arg4 = static_cast< int >(val4);
34628 }
34629 if (obj4) {
34630 ecode5 = SWIG_AsVal_int(obj4, &val5);
34631 if (!SWIG_IsOK(ecode5)) {
34632 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34633 }
34634 arg5 = static_cast< int >(val5);
34635 }
34636 {
34637 PyThreadState* __tstate = wxPyBeginAllowThreads();
34638 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34639 wxPyEndAllowThreads(__tstate);
34640 if (PyErr_Occurred()) SWIG_fail;
34641 }
34642 {
34643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34644 }
34645 return resultobj;
34646 fail:
34647 return NULL;
34648 }
34649
34650
34651 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34652 PyObject *resultobj = 0;
34653 wxWindow *arg1 = (wxWindow *) 0 ;
34654 wxPoint *arg2 = 0 ;
34655 bool result;
34656 void *argp1 = 0 ;
34657 int res1 = 0 ;
34658 wxPoint temp2 ;
34659 PyObject * obj0 = 0 ;
34660 PyObject * obj1 = 0 ;
34661 char * kwnames[] = {
34662 (char *) "self",(char *) "pt", NULL
34663 };
34664
34665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34667 if (!SWIG_IsOK(res1)) {
34668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34669 }
34670 arg1 = reinterpret_cast< wxWindow * >(argp1);
34671 {
34672 arg2 = &temp2;
34673 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34674 }
34675 {
34676 PyThreadState* __tstate = wxPyBeginAllowThreads();
34677 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34678 wxPyEndAllowThreads(__tstate);
34679 if (PyErr_Occurred()) SWIG_fail;
34680 }
34681 {
34682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34683 }
34684 return resultobj;
34685 fail:
34686 return NULL;
34687 }
34688
34689
34690 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34691 PyObject *resultobj = 0;
34692 wxWindow *arg1 = (wxWindow *) 0 ;
34693 wxRect *arg2 = 0 ;
34694 bool result;
34695 void *argp1 = 0 ;
34696 int res1 = 0 ;
34697 wxRect temp2 ;
34698 PyObject * obj0 = 0 ;
34699 PyObject * obj1 = 0 ;
34700 char * kwnames[] = {
34701 (char *) "self",(char *) "rect", NULL
34702 };
34703
34704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34706 if (!SWIG_IsOK(res1)) {
34707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34708 }
34709 arg1 = reinterpret_cast< wxWindow * >(argp1);
34710 {
34711 arg2 = &temp2;
34712 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34713 }
34714 {
34715 PyThreadState* __tstate = wxPyBeginAllowThreads();
34716 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34717 wxPyEndAllowThreads(__tstate);
34718 if (PyErr_Occurred()) SWIG_fail;
34719 }
34720 {
34721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34722 }
34723 return resultobj;
34724 fail:
34725 return NULL;
34726 }
34727
34728
34729 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34730 PyObject *resultobj = 0;
34731 wxWindow *arg1 = (wxWindow *) 0 ;
34732 SwigValueWrapper<wxVisualAttributes > result;
34733 void *argp1 = 0 ;
34734 int res1 = 0 ;
34735 PyObject *swig_obj[1] ;
34736
34737 if (!args) SWIG_fail;
34738 swig_obj[0] = args;
34739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34740 if (!SWIG_IsOK(res1)) {
34741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34742 }
34743 arg1 = reinterpret_cast< wxWindow * >(argp1);
34744 {
34745 PyThreadState* __tstate = wxPyBeginAllowThreads();
34746 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34747 wxPyEndAllowThreads(__tstate);
34748 if (PyErr_Occurred()) SWIG_fail;
34749 }
34750 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34751 return resultobj;
34752 fail:
34753 return NULL;
34754 }
34755
34756
34757 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34758 PyObject *resultobj = 0;
34759 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34760 SwigValueWrapper<wxVisualAttributes > result;
34761 int val1 ;
34762 int ecode1 = 0 ;
34763 PyObject * obj0 = 0 ;
34764 char * kwnames[] = {
34765 (char *) "variant", NULL
34766 };
34767
34768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34769 if (obj0) {
34770 ecode1 = SWIG_AsVal_int(obj0, &val1);
34771 if (!SWIG_IsOK(ecode1)) {
34772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34773 }
34774 arg1 = static_cast< wxWindowVariant >(val1);
34775 }
34776 {
34777 if (!wxPyCheckForApp()) SWIG_fail;
34778 PyThreadState* __tstate = wxPyBeginAllowThreads();
34779 result = wxWindow::GetClassDefaultAttributes(arg1);
34780 wxPyEndAllowThreads(__tstate);
34781 if (PyErr_Occurred()) SWIG_fail;
34782 }
34783 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34784 return resultobj;
34785 fail:
34786 return NULL;
34787 }
34788
34789
34790 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34791 PyObject *resultobj = 0;
34792 wxWindow *arg1 = (wxWindow *) 0 ;
34793 wxColour *arg2 = 0 ;
34794 bool result;
34795 void *argp1 = 0 ;
34796 int res1 = 0 ;
34797 wxColour temp2 ;
34798 PyObject * obj0 = 0 ;
34799 PyObject * obj1 = 0 ;
34800 char * kwnames[] = {
34801 (char *) "self",(char *) "colour", NULL
34802 };
34803
34804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34806 if (!SWIG_IsOK(res1)) {
34807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34808 }
34809 arg1 = reinterpret_cast< wxWindow * >(argp1);
34810 {
34811 arg2 = &temp2;
34812 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34813 }
34814 {
34815 PyThreadState* __tstate = wxPyBeginAllowThreads();
34816 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34817 wxPyEndAllowThreads(__tstate);
34818 if (PyErr_Occurred()) SWIG_fail;
34819 }
34820 {
34821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34822 }
34823 return resultobj;
34824 fail:
34825 return NULL;
34826 }
34827
34828
34829 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34830 PyObject *resultobj = 0;
34831 wxWindow *arg1 = (wxWindow *) 0 ;
34832 wxColour *arg2 = 0 ;
34833 void *argp1 = 0 ;
34834 int res1 = 0 ;
34835 wxColour temp2 ;
34836 PyObject * obj0 = 0 ;
34837 PyObject * obj1 = 0 ;
34838 char * kwnames[] = {
34839 (char *) "self",(char *) "colour", NULL
34840 };
34841
34842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34844 if (!SWIG_IsOK(res1)) {
34845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34846 }
34847 arg1 = reinterpret_cast< wxWindow * >(argp1);
34848 {
34849 arg2 = &temp2;
34850 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34851 }
34852 {
34853 PyThreadState* __tstate = wxPyBeginAllowThreads();
34854 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34855 wxPyEndAllowThreads(__tstate);
34856 if (PyErr_Occurred()) SWIG_fail;
34857 }
34858 resultobj = SWIG_Py_Void();
34859 return resultobj;
34860 fail:
34861 return NULL;
34862 }
34863
34864
34865 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34866 PyObject *resultobj = 0;
34867 wxWindow *arg1 = (wxWindow *) 0 ;
34868 wxColour *arg2 = 0 ;
34869 bool result;
34870 void *argp1 = 0 ;
34871 int res1 = 0 ;
34872 wxColour temp2 ;
34873 PyObject * obj0 = 0 ;
34874 PyObject * obj1 = 0 ;
34875 char * kwnames[] = {
34876 (char *) "self",(char *) "colour", NULL
34877 };
34878
34879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34881 if (!SWIG_IsOK(res1)) {
34882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34883 }
34884 arg1 = reinterpret_cast< wxWindow * >(argp1);
34885 {
34886 arg2 = &temp2;
34887 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34888 }
34889 {
34890 PyThreadState* __tstate = wxPyBeginAllowThreads();
34891 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34892 wxPyEndAllowThreads(__tstate);
34893 if (PyErr_Occurred()) SWIG_fail;
34894 }
34895 {
34896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34897 }
34898 return resultobj;
34899 fail:
34900 return NULL;
34901 }
34902
34903
34904 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34905 PyObject *resultobj = 0;
34906 wxWindow *arg1 = (wxWindow *) 0 ;
34907 wxColour *arg2 = 0 ;
34908 void *argp1 = 0 ;
34909 int res1 = 0 ;
34910 wxColour temp2 ;
34911 PyObject * obj0 = 0 ;
34912 PyObject * obj1 = 0 ;
34913 char * kwnames[] = {
34914 (char *) "self",(char *) "colour", NULL
34915 };
34916
34917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34919 if (!SWIG_IsOK(res1)) {
34920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34921 }
34922 arg1 = reinterpret_cast< wxWindow * >(argp1);
34923 {
34924 arg2 = &temp2;
34925 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34926 }
34927 {
34928 PyThreadState* __tstate = wxPyBeginAllowThreads();
34929 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34930 wxPyEndAllowThreads(__tstate);
34931 if (PyErr_Occurred()) SWIG_fail;
34932 }
34933 resultobj = SWIG_Py_Void();
34934 return resultobj;
34935 fail:
34936 return NULL;
34937 }
34938
34939
34940 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34941 PyObject *resultobj = 0;
34942 wxWindow *arg1 = (wxWindow *) 0 ;
34943 wxColour result;
34944 void *argp1 = 0 ;
34945 int res1 = 0 ;
34946 PyObject *swig_obj[1] ;
34947
34948 if (!args) SWIG_fail;
34949 swig_obj[0] = args;
34950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34951 if (!SWIG_IsOK(res1)) {
34952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34953 }
34954 arg1 = reinterpret_cast< wxWindow * >(argp1);
34955 {
34956 PyThreadState* __tstate = wxPyBeginAllowThreads();
34957 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34958 wxPyEndAllowThreads(__tstate);
34959 if (PyErr_Occurred()) SWIG_fail;
34960 }
34961 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34962 return resultobj;
34963 fail:
34964 return NULL;
34965 }
34966
34967
34968 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34969 PyObject *resultobj = 0;
34970 wxWindow *arg1 = (wxWindow *) 0 ;
34971 wxColour result;
34972 void *argp1 = 0 ;
34973 int res1 = 0 ;
34974 PyObject *swig_obj[1] ;
34975
34976 if (!args) SWIG_fail;
34977 swig_obj[0] = args;
34978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34979 if (!SWIG_IsOK(res1)) {
34980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34981 }
34982 arg1 = reinterpret_cast< wxWindow * >(argp1);
34983 {
34984 PyThreadState* __tstate = wxPyBeginAllowThreads();
34985 result = ((wxWindow const *)arg1)->GetForegroundColour();
34986 wxPyEndAllowThreads(__tstate);
34987 if (PyErr_Occurred()) SWIG_fail;
34988 }
34989 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34990 return resultobj;
34991 fail:
34992 return NULL;
34993 }
34994
34995
34996 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34997 PyObject *resultobj = 0;
34998 wxWindow *arg1 = (wxWindow *) 0 ;
34999 bool result;
35000 void *argp1 = 0 ;
35001 int res1 = 0 ;
35002 PyObject *swig_obj[1] ;
35003
35004 if (!args) SWIG_fail;
35005 swig_obj[0] = args;
35006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35007 if (!SWIG_IsOK(res1)) {
35008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35009 }
35010 arg1 = reinterpret_cast< wxWindow * >(argp1);
35011 {
35012 PyThreadState* __tstate = wxPyBeginAllowThreads();
35013 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35014 wxPyEndAllowThreads(__tstate);
35015 if (PyErr_Occurred()) SWIG_fail;
35016 }
35017 {
35018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35019 }
35020 return resultobj;
35021 fail:
35022 return NULL;
35023 }
35024
35025
35026 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35027 PyObject *resultobj = 0;
35028 wxWindow *arg1 = (wxWindow *) 0 ;
35029 bool result;
35030 void *argp1 = 0 ;
35031 int res1 = 0 ;
35032 PyObject *swig_obj[1] ;
35033
35034 if (!args) SWIG_fail;
35035 swig_obj[0] = args;
35036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35037 if (!SWIG_IsOK(res1)) {
35038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35039 }
35040 arg1 = reinterpret_cast< wxWindow * >(argp1);
35041 {
35042 PyThreadState* __tstate = wxPyBeginAllowThreads();
35043 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35044 wxPyEndAllowThreads(__tstate);
35045 if (PyErr_Occurred()) SWIG_fail;
35046 }
35047 {
35048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35049 }
35050 return resultobj;
35051 fail:
35052 return NULL;
35053 }
35054
35055
35056 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35057 PyObject *resultobj = 0;
35058 wxWindow *arg1 = (wxWindow *) 0 ;
35059 wxBackgroundStyle arg2 ;
35060 bool result;
35061 void *argp1 = 0 ;
35062 int res1 = 0 ;
35063 int val2 ;
35064 int ecode2 = 0 ;
35065 PyObject * obj0 = 0 ;
35066 PyObject * obj1 = 0 ;
35067 char * kwnames[] = {
35068 (char *) "self",(char *) "style", NULL
35069 };
35070
35071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35073 if (!SWIG_IsOK(res1)) {
35074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35075 }
35076 arg1 = reinterpret_cast< wxWindow * >(argp1);
35077 ecode2 = SWIG_AsVal_int(obj1, &val2);
35078 if (!SWIG_IsOK(ecode2)) {
35079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35080 }
35081 arg2 = static_cast< wxBackgroundStyle >(val2);
35082 {
35083 PyThreadState* __tstate = wxPyBeginAllowThreads();
35084 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35085 wxPyEndAllowThreads(__tstate);
35086 if (PyErr_Occurred()) SWIG_fail;
35087 }
35088 {
35089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35090 }
35091 return resultobj;
35092 fail:
35093 return NULL;
35094 }
35095
35096
35097 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35098 PyObject *resultobj = 0;
35099 wxWindow *arg1 = (wxWindow *) 0 ;
35100 wxBackgroundStyle result;
35101 void *argp1 = 0 ;
35102 int res1 = 0 ;
35103 PyObject *swig_obj[1] ;
35104
35105 if (!args) SWIG_fail;
35106 swig_obj[0] = args;
35107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35108 if (!SWIG_IsOK(res1)) {
35109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35110 }
35111 arg1 = reinterpret_cast< wxWindow * >(argp1);
35112 {
35113 PyThreadState* __tstate = wxPyBeginAllowThreads();
35114 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35115 wxPyEndAllowThreads(__tstate);
35116 if (PyErr_Occurred()) SWIG_fail;
35117 }
35118 resultobj = SWIG_From_int(static_cast< int >(result));
35119 return resultobj;
35120 fail:
35121 return NULL;
35122 }
35123
35124
35125 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35126 PyObject *resultobj = 0;
35127 wxWindow *arg1 = (wxWindow *) 0 ;
35128 bool result;
35129 void *argp1 = 0 ;
35130 int res1 = 0 ;
35131 PyObject *swig_obj[1] ;
35132
35133 if (!args) SWIG_fail;
35134 swig_obj[0] = args;
35135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35136 if (!SWIG_IsOK(res1)) {
35137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35138 }
35139 arg1 = reinterpret_cast< wxWindow * >(argp1);
35140 {
35141 PyThreadState* __tstate = wxPyBeginAllowThreads();
35142 result = (bool)(arg1)->HasTransparentBackground();
35143 wxPyEndAllowThreads(__tstate);
35144 if (PyErr_Occurred()) SWIG_fail;
35145 }
35146 {
35147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35148 }
35149 return resultobj;
35150 fail:
35151 return NULL;
35152 }
35153
35154
35155 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35156 PyObject *resultobj = 0;
35157 wxWindow *arg1 = (wxWindow *) 0 ;
35158 wxCursor *arg2 = 0 ;
35159 bool result;
35160 void *argp1 = 0 ;
35161 int res1 = 0 ;
35162 void *argp2 = 0 ;
35163 int res2 = 0 ;
35164 PyObject * obj0 = 0 ;
35165 PyObject * obj1 = 0 ;
35166 char * kwnames[] = {
35167 (char *) "self",(char *) "cursor", NULL
35168 };
35169
35170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35172 if (!SWIG_IsOK(res1)) {
35173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35174 }
35175 arg1 = reinterpret_cast< wxWindow * >(argp1);
35176 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35177 if (!SWIG_IsOK(res2)) {
35178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35179 }
35180 if (!argp2) {
35181 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35182 }
35183 arg2 = reinterpret_cast< wxCursor * >(argp2);
35184 {
35185 PyThreadState* __tstate = wxPyBeginAllowThreads();
35186 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35187 wxPyEndAllowThreads(__tstate);
35188 if (PyErr_Occurred()) SWIG_fail;
35189 }
35190 {
35191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35192 }
35193 return resultobj;
35194 fail:
35195 return NULL;
35196 }
35197
35198
35199 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35200 PyObject *resultobj = 0;
35201 wxWindow *arg1 = (wxWindow *) 0 ;
35202 wxCursor result;
35203 void *argp1 = 0 ;
35204 int res1 = 0 ;
35205 PyObject *swig_obj[1] ;
35206
35207 if (!args) SWIG_fail;
35208 swig_obj[0] = args;
35209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35210 if (!SWIG_IsOK(res1)) {
35211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35212 }
35213 arg1 = reinterpret_cast< wxWindow * >(argp1);
35214 {
35215 PyThreadState* __tstate = wxPyBeginAllowThreads();
35216 result = (arg1)->GetCursor();
35217 wxPyEndAllowThreads(__tstate);
35218 if (PyErr_Occurred()) SWIG_fail;
35219 }
35220 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35221 return resultobj;
35222 fail:
35223 return NULL;
35224 }
35225
35226
35227 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35228 PyObject *resultobj = 0;
35229 wxWindow *arg1 = (wxWindow *) 0 ;
35230 wxFont *arg2 = 0 ;
35231 bool result;
35232 void *argp1 = 0 ;
35233 int res1 = 0 ;
35234 void *argp2 = 0 ;
35235 int res2 = 0 ;
35236 PyObject * obj0 = 0 ;
35237 PyObject * obj1 = 0 ;
35238 char * kwnames[] = {
35239 (char *) "self",(char *) "font", NULL
35240 };
35241
35242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35244 if (!SWIG_IsOK(res1)) {
35245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35246 }
35247 arg1 = reinterpret_cast< wxWindow * >(argp1);
35248 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35249 if (!SWIG_IsOK(res2)) {
35250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35251 }
35252 if (!argp2) {
35253 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35254 }
35255 arg2 = reinterpret_cast< wxFont * >(argp2);
35256 {
35257 PyThreadState* __tstate = wxPyBeginAllowThreads();
35258 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35259 wxPyEndAllowThreads(__tstate);
35260 if (PyErr_Occurred()) SWIG_fail;
35261 }
35262 {
35263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35264 }
35265 return resultobj;
35266 fail:
35267 return NULL;
35268 }
35269
35270
35271 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35272 PyObject *resultobj = 0;
35273 wxWindow *arg1 = (wxWindow *) 0 ;
35274 wxFont *arg2 = 0 ;
35275 void *argp1 = 0 ;
35276 int res1 = 0 ;
35277 void *argp2 = 0 ;
35278 int res2 = 0 ;
35279 PyObject * obj0 = 0 ;
35280 PyObject * obj1 = 0 ;
35281 char * kwnames[] = {
35282 (char *) "self",(char *) "font", NULL
35283 };
35284
35285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35287 if (!SWIG_IsOK(res1)) {
35288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35289 }
35290 arg1 = reinterpret_cast< wxWindow * >(argp1);
35291 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35292 if (!SWIG_IsOK(res2)) {
35293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35294 }
35295 if (!argp2) {
35296 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35297 }
35298 arg2 = reinterpret_cast< wxFont * >(argp2);
35299 {
35300 PyThreadState* __tstate = wxPyBeginAllowThreads();
35301 (arg1)->SetOwnFont((wxFont const &)*arg2);
35302 wxPyEndAllowThreads(__tstate);
35303 if (PyErr_Occurred()) SWIG_fail;
35304 }
35305 resultobj = SWIG_Py_Void();
35306 return resultobj;
35307 fail:
35308 return NULL;
35309 }
35310
35311
35312 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35313 PyObject *resultobj = 0;
35314 wxWindow *arg1 = (wxWindow *) 0 ;
35315 wxFont result;
35316 void *argp1 = 0 ;
35317 int res1 = 0 ;
35318 PyObject *swig_obj[1] ;
35319
35320 if (!args) SWIG_fail;
35321 swig_obj[0] = args;
35322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35323 if (!SWIG_IsOK(res1)) {
35324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35325 }
35326 arg1 = reinterpret_cast< wxWindow * >(argp1);
35327 {
35328 PyThreadState* __tstate = wxPyBeginAllowThreads();
35329 result = (arg1)->GetFont();
35330 wxPyEndAllowThreads(__tstate);
35331 if (PyErr_Occurred()) SWIG_fail;
35332 }
35333 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35334 return resultobj;
35335 fail:
35336 return NULL;
35337 }
35338
35339
35340 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35341 PyObject *resultobj = 0;
35342 wxWindow *arg1 = (wxWindow *) 0 ;
35343 wxCaret *arg2 = (wxCaret *) 0 ;
35344 void *argp1 = 0 ;
35345 int res1 = 0 ;
35346 int res2 = 0 ;
35347 PyObject * obj0 = 0 ;
35348 PyObject * obj1 = 0 ;
35349 char * kwnames[] = {
35350 (char *) "self",(char *) "caret", NULL
35351 };
35352
35353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35355 if (!SWIG_IsOK(res1)) {
35356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35357 }
35358 arg1 = reinterpret_cast< wxWindow * >(argp1);
35359 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35360 if (!SWIG_IsOK(res2)) {
35361 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35362 }
35363 {
35364 PyThreadState* __tstate = wxPyBeginAllowThreads();
35365 (arg1)->SetCaret(arg2);
35366 wxPyEndAllowThreads(__tstate);
35367 if (PyErr_Occurred()) SWIG_fail;
35368 }
35369 resultobj = SWIG_Py_Void();
35370 return resultobj;
35371 fail:
35372 return NULL;
35373 }
35374
35375
35376 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35377 PyObject *resultobj = 0;
35378 wxWindow *arg1 = (wxWindow *) 0 ;
35379 wxCaret *result = 0 ;
35380 void *argp1 = 0 ;
35381 int res1 = 0 ;
35382 PyObject *swig_obj[1] ;
35383
35384 if (!args) SWIG_fail;
35385 swig_obj[0] = args;
35386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35387 if (!SWIG_IsOK(res1)) {
35388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35389 }
35390 arg1 = reinterpret_cast< wxWindow * >(argp1);
35391 {
35392 PyThreadState* __tstate = wxPyBeginAllowThreads();
35393 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35394 wxPyEndAllowThreads(__tstate);
35395 if (PyErr_Occurred()) SWIG_fail;
35396 }
35397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35398 return resultobj;
35399 fail:
35400 return NULL;
35401 }
35402
35403
35404 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35405 PyObject *resultobj = 0;
35406 wxWindow *arg1 = (wxWindow *) 0 ;
35407 int result;
35408 void *argp1 = 0 ;
35409 int res1 = 0 ;
35410 PyObject *swig_obj[1] ;
35411
35412 if (!args) SWIG_fail;
35413 swig_obj[0] = args;
35414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35415 if (!SWIG_IsOK(res1)) {
35416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35417 }
35418 arg1 = reinterpret_cast< wxWindow * >(argp1);
35419 {
35420 PyThreadState* __tstate = wxPyBeginAllowThreads();
35421 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35422 wxPyEndAllowThreads(__tstate);
35423 if (PyErr_Occurred()) SWIG_fail;
35424 }
35425 resultobj = SWIG_From_int(static_cast< int >(result));
35426 return resultobj;
35427 fail:
35428 return NULL;
35429 }
35430
35431
35432 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35433 PyObject *resultobj = 0;
35434 wxWindow *arg1 = (wxWindow *) 0 ;
35435 int result;
35436 void *argp1 = 0 ;
35437 int res1 = 0 ;
35438 PyObject *swig_obj[1] ;
35439
35440 if (!args) SWIG_fail;
35441 swig_obj[0] = args;
35442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35443 if (!SWIG_IsOK(res1)) {
35444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35445 }
35446 arg1 = reinterpret_cast< wxWindow * >(argp1);
35447 {
35448 PyThreadState* __tstate = wxPyBeginAllowThreads();
35449 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35450 wxPyEndAllowThreads(__tstate);
35451 if (PyErr_Occurred()) SWIG_fail;
35452 }
35453 resultobj = SWIG_From_int(static_cast< int >(result));
35454 return resultobj;
35455 fail:
35456 return NULL;
35457 }
35458
35459
35460 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35461 PyObject *resultobj = 0;
35462 wxWindow *arg1 = (wxWindow *) 0 ;
35463 wxString *arg2 = 0 ;
35464 int *arg3 = (int *) 0 ;
35465 int *arg4 = (int *) 0 ;
35466 void *argp1 = 0 ;
35467 int res1 = 0 ;
35468 bool temp2 = false ;
35469 int temp3 ;
35470 int res3 = SWIG_TMPOBJ ;
35471 int temp4 ;
35472 int res4 = SWIG_TMPOBJ ;
35473 PyObject * obj0 = 0 ;
35474 PyObject * obj1 = 0 ;
35475 char * kwnames[] = {
35476 (char *) "self",(char *) "string", NULL
35477 };
35478
35479 arg3 = &temp3;
35480 arg4 = &temp4;
35481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35483 if (!SWIG_IsOK(res1)) {
35484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35485 }
35486 arg1 = reinterpret_cast< wxWindow * >(argp1);
35487 {
35488 arg2 = wxString_in_helper(obj1);
35489 if (arg2 == NULL) SWIG_fail;
35490 temp2 = true;
35491 }
35492 {
35493 PyThreadState* __tstate = wxPyBeginAllowThreads();
35494 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35495 wxPyEndAllowThreads(__tstate);
35496 if (PyErr_Occurred()) SWIG_fail;
35497 }
35498 resultobj = SWIG_Py_Void();
35499 if (SWIG_IsTmpObj(res3)) {
35500 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35501 } else {
35502 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35503 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35504 }
35505 if (SWIG_IsTmpObj(res4)) {
35506 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35507 } else {
35508 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35509 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35510 }
35511 {
35512 if (temp2)
35513 delete arg2;
35514 }
35515 return resultobj;
35516 fail:
35517 {
35518 if (temp2)
35519 delete arg2;
35520 }
35521 return NULL;
35522 }
35523
35524
35525 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35526 PyObject *resultobj = 0;
35527 wxWindow *arg1 = (wxWindow *) 0 ;
35528 wxString *arg2 = 0 ;
35529 int *arg3 = (int *) 0 ;
35530 int *arg4 = (int *) 0 ;
35531 int *arg5 = (int *) 0 ;
35532 int *arg6 = (int *) 0 ;
35533 wxFont *arg7 = (wxFont *) NULL ;
35534 void *argp1 = 0 ;
35535 int res1 = 0 ;
35536 bool temp2 = false ;
35537 int temp3 ;
35538 int res3 = SWIG_TMPOBJ ;
35539 int temp4 ;
35540 int res4 = SWIG_TMPOBJ ;
35541 int temp5 ;
35542 int res5 = SWIG_TMPOBJ ;
35543 int temp6 ;
35544 int res6 = SWIG_TMPOBJ ;
35545 void *argp7 = 0 ;
35546 int res7 = 0 ;
35547 PyObject * obj0 = 0 ;
35548 PyObject * obj1 = 0 ;
35549 PyObject * obj2 = 0 ;
35550 char * kwnames[] = {
35551 (char *) "self",(char *) "string",(char *) "font", NULL
35552 };
35553
35554 arg3 = &temp3;
35555 arg4 = &temp4;
35556 arg5 = &temp5;
35557 arg6 = &temp6;
35558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35560 if (!SWIG_IsOK(res1)) {
35561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35562 }
35563 arg1 = reinterpret_cast< wxWindow * >(argp1);
35564 {
35565 arg2 = wxString_in_helper(obj1);
35566 if (arg2 == NULL) SWIG_fail;
35567 temp2 = true;
35568 }
35569 if (obj2) {
35570 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35571 if (!SWIG_IsOK(res7)) {
35572 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35573 }
35574 arg7 = reinterpret_cast< wxFont * >(argp7);
35575 }
35576 {
35577 PyThreadState* __tstate = wxPyBeginAllowThreads();
35578 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35579 wxPyEndAllowThreads(__tstate);
35580 if (PyErr_Occurred()) SWIG_fail;
35581 }
35582 resultobj = SWIG_Py_Void();
35583 if (SWIG_IsTmpObj(res3)) {
35584 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35585 } else {
35586 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35587 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35588 }
35589 if (SWIG_IsTmpObj(res4)) {
35590 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35591 } else {
35592 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35593 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35594 }
35595 if (SWIG_IsTmpObj(res5)) {
35596 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35597 } else {
35598 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35599 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35600 }
35601 if (SWIG_IsTmpObj(res6)) {
35602 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35603 } else {
35604 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35605 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35606 }
35607 {
35608 if (temp2)
35609 delete arg2;
35610 }
35611 return resultobj;
35612 fail:
35613 {
35614 if (temp2)
35615 delete arg2;
35616 }
35617 return NULL;
35618 }
35619
35620
35621 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35622 PyObject *resultobj = 0;
35623 wxWindow *arg1 = (wxWindow *) 0 ;
35624 int *arg2 = (int *) 0 ;
35625 int *arg3 = (int *) 0 ;
35626 void *argp1 = 0 ;
35627 int res1 = 0 ;
35628 int temp2 ;
35629 int res2 = 0 ;
35630 int temp3 ;
35631 int res3 = 0 ;
35632 PyObject * obj0 = 0 ;
35633 PyObject * obj1 = 0 ;
35634 PyObject * obj2 = 0 ;
35635 char * kwnames[] = {
35636 (char *) "self",(char *) "x",(char *) "y", NULL
35637 };
35638
35639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35641 if (!SWIG_IsOK(res1)) {
35642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35643 }
35644 arg1 = reinterpret_cast< wxWindow * >(argp1);
35645 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35646 int val;
35647 int ecode = SWIG_AsVal_int(obj1, &val);
35648 if (!SWIG_IsOK(ecode)) {
35649 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35650 }
35651 temp2 = static_cast< int >(val);
35652 arg2 = &temp2;
35653 res2 = SWIG_AddTmpMask(ecode);
35654 }
35655 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35656 int val;
35657 int ecode = SWIG_AsVal_int(obj2, &val);
35658 if (!SWIG_IsOK(ecode)) {
35659 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35660 }
35661 temp3 = static_cast< int >(val);
35662 arg3 = &temp3;
35663 res3 = SWIG_AddTmpMask(ecode);
35664 }
35665 {
35666 PyThreadState* __tstate = wxPyBeginAllowThreads();
35667 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35668 wxPyEndAllowThreads(__tstate);
35669 if (PyErr_Occurred()) SWIG_fail;
35670 }
35671 resultobj = SWIG_Py_Void();
35672 if (SWIG_IsTmpObj(res2)) {
35673 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35674 } else {
35675 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35676 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35677 }
35678 if (SWIG_IsTmpObj(res3)) {
35679 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35680 } else {
35681 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35682 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35683 }
35684 return resultobj;
35685 fail:
35686 return NULL;
35687 }
35688
35689
35690 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35691 PyObject *resultobj = 0;
35692 wxWindow *arg1 = (wxWindow *) 0 ;
35693 int *arg2 = (int *) 0 ;
35694 int *arg3 = (int *) 0 ;
35695 void *argp1 = 0 ;
35696 int res1 = 0 ;
35697 int temp2 ;
35698 int res2 = 0 ;
35699 int temp3 ;
35700 int res3 = 0 ;
35701 PyObject * obj0 = 0 ;
35702 PyObject * obj1 = 0 ;
35703 PyObject * obj2 = 0 ;
35704 char * kwnames[] = {
35705 (char *) "self",(char *) "x",(char *) "y", NULL
35706 };
35707
35708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35710 if (!SWIG_IsOK(res1)) {
35711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35712 }
35713 arg1 = reinterpret_cast< wxWindow * >(argp1);
35714 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35715 int val;
35716 int ecode = SWIG_AsVal_int(obj1, &val);
35717 if (!SWIG_IsOK(ecode)) {
35718 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35719 }
35720 temp2 = static_cast< int >(val);
35721 arg2 = &temp2;
35722 res2 = SWIG_AddTmpMask(ecode);
35723 }
35724 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35725 int val;
35726 int ecode = SWIG_AsVal_int(obj2, &val);
35727 if (!SWIG_IsOK(ecode)) {
35728 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35729 }
35730 temp3 = static_cast< int >(val);
35731 arg3 = &temp3;
35732 res3 = SWIG_AddTmpMask(ecode);
35733 }
35734 {
35735 PyThreadState* __tstate = wxPyBeginAllowThreads();
35736 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35737 wxPyEndAllowThreads(__tstate);
35738 if (PyErr_Occurred()) SWIG_fail;
35739 }
35740 resultobj = SWIG_Py_Void();
35741 if (SWIG_IsTmpObj(res2)) {
35742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35743 } else {
35744 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35745 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35746 }
35747 if (SWIG_IsTmpObj(res3)) {
35748 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35749 } else {
35750 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35751 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35752 }
35753 return resultobj;
35754 fail:
35755 return NULL;
35756 }
35757
35758
35759 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35760 PyObject *resultobj = 0;
35761 wxWindow *arg1 = (wxWindow *) 0 ;
35762 wxPoint *arg2 = 0 ;
35763 wxPoint result;
35764 void *argp1 = 0 ;
35765 int res1 = 0 ;
35766 wxPoint temp2 ;
35767 PyObject * obj0 = 0 ;
35768 PyObject * obj1 = 0 ;
35769 char * kwnames[] = {
35770 (char *) "self",(char *) "pt", NULL
35771 };
35772
35773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35775 if (!SWIG_IsOK(res1)) {
35776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35777 }
35778 arg1 = reinterpret_cast< wxWindow * >(argp1);
35779 {
35780 arg2 = &temp2;
35781 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35782 }
35783 {
35784 PyThreadState* __tstate = wxPyBeginAllowThreads();
35785 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35786 wxPyEndAllowThreads(__tstate);
35787 if (PyErr_Occurred()) SWIG_fail;
35788 }
35789 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35790 return resultobj;
35791 fail:
35792 return NULL;
35793 }
35794
35795
35796 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35797 PyObject *resultobj = 0;
35798 wxWindow *arg1 = (wxWindow *) 0 ;
35799 wxPoint *arg2 = 0 ;
35800 wxPoint result;
35801 void *argp1 = 0 ;
35802 int res1 = 0 ;
35803 wxPoint temp2 ;
35804 PyObject * obj0 = 0 ;
35805 PyObject * obj1 = 0 ;
35806 char * kwnames[] = {
35807 (char *) "self",(char *) "pt", NULL
35808 };
35809
35810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35812 if (!SWIG_IsOK(res1)) {
35813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35814 }
35815 arg1 = reinterpret_cast< wxWindow * >(argp1);
35816 {
35817 arg2 = &temp2;
35818 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35819 }
35820 {
35821 PyThreadState* __tstate = wxPyBeginAllowThreads();
35822 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35823 wxPyEndAllowThreads(__tstate);
35824 if (PyErr_Occurred()) SWIG_fail;
35825 }
35826 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35827 return resultobj;
35828 fail:
35829 return NULL;
35830 }
35831
35832
35833 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35834 PyObject *resultobj = 0;
35835 wxWindow *arg1 = (wxWindow *) 0 ;
35836 int arg2 ;
35837 int arg3 ;
35838 wxHitTest result;
35839 void *argp1 = 0 ;
35840 int res1 = 0 ;
35841 int val2 ;
35842 int ecode2 = 0 ;
35843 int val3 ;
35844 int ecode3 = 0 ;
35845 PyObject * obj0 = 0 ;
35846 PyObject * obj1 = 0 ;
35847 PyObject * obj2 = 0 ;
35848 char * kwnames[] = {
35849 (char *) "self",(char *) "x",(char *) "y", NULL
35850 };
35851
35852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35854 if (!SWIG_IsOK(res1)) {
35855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35856 }
35857 arg1 = reinterpret_cast< wxWindow * >(argp1);
35858 ecode2 = SWIG_AsVal_int(obj1, &val2);
35859 if (!SWIG_IsOK(ecode2)) {
35860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35861 }
35862 arg2 = static_cast< int >(val2);
35863 ecode3 = SWIG_AsVal_int(obj2, &val3);
35864 if (!SWIG_IsOK(ecode3)) {
35865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35866 }
35867 arg3 = static_cast< int >(val3);
35868 {
35869 PyThreadState* __tstate = wxPyBeginAllowThreads();
35870 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35871 wxPyEndAllowThreads(__tstate);
35872 if (PyErr_Occurred()) SWIG_fail;
35873 }
35874 resultobj = SWIG_From_int(static_cast< int >(result));
35875 return resultobj;
35876 fail:
35877 return NULL;
35878 }
35879
35880
35881 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35882 PyObject *resultobj = 0;
35883 wxWindow *arg1 = (wxWindow *) 0 ;
35884 wxPoint *arg2 = 0 ;
35885 wxHitTest result;
35886 void *argp1 = 0 ;
35887 int res1 = 0 ;
35888 wxPoint temp2 ;
35889 PyObject * obj0 = 0 ;
35890 PyObject * obj1 = 0 ;
35891 char * kwnames[] = {
35892 (char *) "self",(char *) "pt", NULL
35893 };
35894
35895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35897 if (!SWIG_IsOK(res1)) {
35898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35899 }
35900 arg1 = reinterpret_cast< wxWindow * >(argp1);
35901 {
35902 arg2 = &temp2;
35903 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35904 }
35905 {
35906 PyThreadState* __tstate = wxPyBeginAllowThreads();
35907 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35908 wxPyEndAllowThreads(__tstate);
35909 if (PyErr_Occurred()) SWIG_fail;
35910 }
35911 resultobj = SWIG_From_int(static_cast< int >(result));
35912 return resultobj;
35913 fail:
35914 return NULL;
35915 }
35916
35917
35918 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35919 PyObject *resultobj = 0;
35920 wxWindow *arg1 = (wxWindow *) 0 ;
35921 long arg2 ;
35922 wxBorder result;
35923 void *argp1 = 0 ;
35924 int res1 = 0 ;
35925 long val2 ;
35926 int ecode2 = 0 ;
35927
35928 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35930 if (!SWIG_IsOK(res1)) {
35931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35932 }
35933 arg1 = reinterpret_cast< wxWindow * >(argp1);
35934 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35935 if (!SWIG_IsOK(ecode2)) {
35936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35937 }
35938 arg2 = static_cast< long >(val2);
35939 {
35940 PyThreadState* __tstate = wxPyBeginAllowThreads();
35941 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35942 wxPyEndAllowThreads(__tstate);
35943 if (PyErr_Occurred()) SWIG_fail;
35944 }
35945 resultobj = SWIG_From_int(static_cast< int >(result));
35946 return resultobj;
35947 fail:
35948 return NULL;
35949 }
35950
35951
35952 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35953 PyObject *resultobj = 0;
35954 wxWindow *arg1 = (wxWindow *) 0 ;
35955 wxBorder result;
35956 void *argp1 = 0 ;
35957 int res1 = 0 ;
35958
35959 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35961 if (!SWIG_IsOK(res1)) {
35962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35963 }
35964 arg1 = reinterpret_cast< wxWindow * >(argp1);
35965 {
35966 PyThreadState* __tstate = wxPyBeginAllowThreads();
35967 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35968 wxPyEndAllowThreads(__tstate);
35969 if (PyErr_Occurred()) SWIG_fail;
35970 }
35971 resultobj = SWIG_From_int(static_cast< int >(result));
35972 return resultobj;
35973 fail:
35974 return NULL;
35975 }
35976
35977
35978 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35979 int argc;
35980 PyObject *argv[3];
35981
35982 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35983 --argc;
35984 if (argc == 1) {
35985 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35986 }
35987 if (argc == 2) {
35988 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35989 }
35990
35991 fail:
35992 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35993 return NULL;
35994 }
35995
35996
35997 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35998 PyObject *resultobj = 0;
35999 wxWindow *arg1 = (wxWindow *) 0 ;
36000 long arg2 = (long) wxUPDATE_UI_NONE ;
36001 void *argp1 = 0 ;
36002 int res1 = 0 ;
36003 long val2 ;
36004 int ecode2 = 0 ;
36005 PyObject * obj0 = 0 ;
36006 PyObject * obj1 = 0 ;
36007 char * kwnames[] = {
36008 (char *) "self",(char *) "flags", NULL
36009 };
36010
36011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36013 if (!SWIG_IsOK(res1)) {
36014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36015 }
36016 arg1 = reinterpret_cast< wxWindow * >(argp1);
36017 if (obj1) {
36018 ecode2 = SWIG_AsVal_long(obj1, &val2);
36019 if (!SWIG_IsOK(ecode2)) {
36020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36021 }
36022 arg2 = static_cast< long >(val2);
36023 }
36024 {
36025 PyThreadState* __tstate = wxPyBeginAllowThreads();
36026 (arg1)->UpdateWindowUI(arg2);
36027 wxPyEndAllowThreads(__tstate);
36028 if (PyErr_Occurred()) SWIG_fail;
36029 }
36030 resultobj = SWIG_Py_Void();
36031 return resultobj;
36032 fail:
36033 return NULL;
36034 }
36035
36036
36037 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36038 PyObject *resultobj = 0;
36039 wxWindow *arg1 = (wxWindow *) 0 ;
36040 wxMenu *arg2 = (wxMenu *) 0 ;
36041 int arg3 = (int) -1 ;
36042 int arg4 = (int) -1 ;
36043 bool result;
36044 void *argp1 = 0 ;
36045 int res1 = 0 ;
36046 void *argp2 = 0 ;
36047 int res2 = 0 ;
36048 int val3 ;
36049 int ecode3 = 0 ;
36050 int val4 ;
36051 int ecode4 = 0 ;
36052 PyObject * obj0 = 0 ;
36053 PyObject * obj1 = 0 ;
36054 PyObject * obj2 = 0 ;
36055 PyObject * obj3 = 0 ;
36056 char * kwnames[] = {
36057 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36058 };
36059
36060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36062 if (!SWIG_IsOK(res1)) {
36063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36064 }
36065 arg1 = reinterpret_cast< wxWindow * >(argp1);
36066 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36067 if (!SWIG_IsOK(res2)) {
36068 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36069 }
36070 arg2 = reinterpret_cast< wxMenu * >(argp2);
36071 if (obj2) {
36072 ecode3 = SWIG_AsVal_int(obj2, &val3);
36073 if (!SWIG_IsOK(ecode3)) {
36074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36075 }
36076 arg3 = static_cast< int >(val3);
36077 }
36078 if (obj3) {
36079 ecode4 = SWIG_AsVal_int(obj3, &val4);
36080 if (!SWIG_IsOK(ecode4)) {
36081 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36082 }
36083 arg4 = static_cast< int >(val4);
36084 }
36085 {
36086 PyThreadState* __tstate = wxPyBeginAllowThreads();
36087 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36088 wxPyEndAllowThreads(__tstate);
36089 if (PyErr_Occurred()) SWIG_fail;
36090 }
36091 {
36092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36093 }
36094 return resultobj;
36095 fail:
36096 return NULL;
36097 }
36098
36099
36100 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36101 PyObject *resultobj = 0;
36102 wxWindow *arg1 = (wxWindow *) 0 ;
36103 wxMenu *arg2 = (wxMenu *) 0 ;
36104 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36105 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36106 bool result;
36107 void *argp1 = 0 ;
36108 int res1 = 0 ;
36109 void *argp2 = 0 ;
36110 int res2 = 0 ;
36111 wxPoint temp3 ;
36112 PyObject * obj0 = 0 ;
36113 PyObject * obj1 = 0 ;
36114 PyObject * obj2 = 0 ;
36115 char * kwnames[] = {
36116 (char *) "self",(char *) "menu",(char *) "pos", NULL
36117 };
36118
36119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36121 if (!SWIG_IsOK(res1)) {
36122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36123 }
36124 arg1 = reinterpret_cast< wxWindow * >(argp1);
36125 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36126 if (!SWIG_IsOK(res2)) {
36127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36128 }
36129 arg2 = reinterpret_cast< wxMenu * >(argp2);
36130 if (obj2) {
36131 {
36132 arg3 = &temp3;
36133 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36134 }
36135 }
36136 {
36137 PyThreadState* __tstate = wxPyBeginAllowThreads();
36138 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36139 wxPyEndAllowThreads(__tstate);
36140 if (PyErr_Occurred()) SWIG_fail;
36141 }
36142 {
36143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36144 }
36145 return resultobj;
36146 fail:
36147 return NULL;
36148 }
36149
36150
36151 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36152 PyObject *resultobj = 0;
36153 wxWindow *arg1 = (wxWindow *) 0 ;
36154 bool result;
36155 void *argp1 = 0 ;
36156 int res1 = 0 ;
36157 PyObject *swig_obj[1] ;
36158
36159 if (!args) SWIG_fail;
36160 swig_obj[0] = args;
36161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36162 if (!SWIG_IsOK(res1)) {
36163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36164 }
36165 arg1 = reinterpret_cast< wxWindow * >(argp1);
36166 {
36167 PyThreadState* __tstate = wxPyBeginAllowThreads();
36168 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36169 wxPyEndAllowThreads(__tstate);
36170 if (PyErr_Occurred()) SWIG_fail;
36171 }
36172 {
36173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36174 }
36175 return resultobj;
36176 fail:
36177 return NULL;
36178 }
36179
36180
36181 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36182 PyObject *resultobj = 0;
36183 wxWindow *arg1 = (wxWindow *) 0 ;
36184 long result;
36185 void *argp1 = 0 ;
36186 int res1 = 0 ;
36187 PyObject *swig_obj[1] ;
36188
36189 if (!args) SWIG_fail;
36190 swig_obj[0] = args;
36191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36192 if (!SWIG_IsOK(res1)) {
36193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36194 }
36195 arg1 = reinterpret_cast< wxWindow * >(argp1);
36196 {
36197 PyThreadState* __tstate = wxPyBeginAllowThreads();
36198 result = (long)wxWindow_GetHandle(arg1);
36199 wxPyEndAllowThreads(__tstate);
36200 if (PyErr_Occurred()) SWIG_fail;
36201 }
36202 resultobj = SWIG_From_long(static_cast< long >(result));
36203 return resultobj;
36204 fail:
36205 return NULL;
36206 }
36207
36208
36209 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36210 PyObject *resultobj = 0;
36211 wxWindow *arg1 = (wxWindow *) 0 ;
36212 long arg2 ;
36213 void *argp1 = 0 ;
36214 int res1 = 0 ;
36215 long val2 ;
36216 int ecode2 = 0 ;
36217 PyObject * obj0 = 0 ;
36218 PyObject * obj1 = 0 ;
36219 char * kwnames[] = {
36220 (char *) "self",(char *) "handle", NULL
36221 };
36222
36223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36225 if (!SWIG_IsOK(res1)) {
36226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36227 }
36228 arg1 = reinterpret_cast< wxWindow * >(argp1);
36229 ecode2 = SWIG_AsVal_long(obj1, &val2);
36230 if (!SWIG_IsOK(ecode2)) {
36231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36232 }
36233 arg2 = static_cast< long >(val2);
36234 {
36235 PyThreadState* __tstate = wxPyBeginAllowThreads();
36236 wxWindow_AssociateHandle(arg1,arg2);
36237 wxPyEndAllowThreads(__tstate);
36238 if (PyErr_Occurred()) SWIG_fail;
36239 }
36240 resultobj = SWIG_Py_Void();
36241 return resultobj;
36242 fail:
36243 return NULL;
36244 }
36245
36246
36247 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36248 PyObject *resultobj = 0;
36249 wxWindow *arg1 = (wxWindow *) 0 ;
36250 void *argp1 = 0 ;
36251 int res1 = 0 ;
36252 PyObject *swig_obj[1] ;
36253
36254 if (!args) SWIG_fail;
36255 swig_obj[0] = args;
36256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36257 if (!SWIG_IsOK(res1)) {
36258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36259 }
36260 arg1 = reinterpret_cast< wxWindow * >(argp1);
36261 {
36262 PyThreadState* __tstate = wxPyBeginAllowThreads();
36263 (arg1)->DissociateHandle();
36264 wxPyEndAllowThreads(__tstate);
36265 if (PyErr_Occurred()) SWIG_fail;
36266 }
36267 resultobj = SWIG_Py_Void();
36268 return resultobj;
36269 fail:
36270 return NULL;
36271 }
36272
36273
36274 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36275 PyObject *resultobj = 0;
36276 wxWindow *arg1 = (wxWindow *) 0 ;
36277 wxPaintEvent *arg2 = 0 ;
36278 void *argp1 = 0 ;
36279 int res1 = 0 ;
36280 void *argp2 = 0 ;
36281 int res2 = 0 ;
36282 PyObject * obj0 = 0 ;
36283 PyObject * obj1 = 0 ;
36284 char * kwnames[] = {
36285 (char *) "self",(char *) "event", NULL
36286 };
36287
36288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36290 if (!SWIG_IsOK(res1)) {
36291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36292 }
36293 arg1 = reinterpret_cast< wxWindow * >(argp1);
36294 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36295 if (!SWIG_IsOK(res2)) {
36296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36297 }
36298 if (!argp2) {
36299 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36300 }
36301 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36302 {
36303 PyThreadState* __tstate = wxPyBeginAllowThreads();
36304 (arg1)->OnPaint(*arg2);
36305 wxPyEndAllowThreads(__tstate);
36306 if (PyErr_Occurred()) SWIG_fail;
36307 }
36308 resultobj = SWIG_Py_Void();
36309 return resultobj;
36310 fail:
36311 return NULL;
36312 }
36313
36314
36315 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36316 PyObject *resultobj = 0;
36317 wxWindow *arg1 = (wxWindow *) 0 ;
36318 int arg2 ;
36319 bool result;
36320 void *argp1 = 0 ;
36321 int res1 = 0 ;
36322 int val2 ;
36323 int ecode2 = 0 ;
36324 PyObject * obj0 = 0 ;
36325 PyObject * obj1 = 0 ;
36326 char * kwnames[] = {
36327 (char *) "self",(char *) "orient", NULL
36328 };
36329
36330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36332 if (!SWIG_IsOK(res1)) {
36333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36334 }
36335 arg1 = reinterpret_cast< wxWindow * >(argp1);
36336 ecode2 = SWIG_AsVal_int(obj1, &val2);
36337 if (!SWIG_IsOK(ecode2)) {
36338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36339 }
36340 arg2 = static_cast< int >(val2);
36341 {
36342 PyThreadState* __tstate = wxPyBeginAllowThreads();
36343 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36344 wxPyEndAllowThreads(__tstate);
36345 if (PyErr_Occurred()) SWIG_fail;
36346 }
36347 {
36348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36349 }
36350 return resultobj;
36351 fail:
36352 return NULL;
36353 }
36354
36355
36356 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36357 PyObject *resultobj = 0;
36358 wxWindow *arg1 = (wxWindow *) 0 ;
36359 int arg2 ;
36360 int arg3 ;
36361 int arg4 ;
36362 int arg5 ;
36363 bool arg6 = (bool) true ;
36364 void *argp1 = 0 ;
36365 int res1 = 0 ;
36366 int val2 ;
36367 int ecode2 = 0 ;
36368 int val3 ;
36369 int ecode3 = 0 ;
36370 int val4 ;
36371 int ecode4 = 0 ;
36372 int val5 ;
36373 int ecode5 = 0 ;
36374 bool val6 ;
36375 int ecode6 = 0 ;
36376 PyObject * obj0 = 0 ;
36377 PyObject * obj1 = 0 ;
36378 PyObject * obj2 = 0 ;
36379 PyObject * obj3 = 0 ;
36380 PyObject * obj4 = 0 ;
36381 PyObject * obj5 = 0 ;
36382 char * kwnames[] = {
36383 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36384 };
36385
36386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36388 if (!SWIG_IsOK(res1)) {
36389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36390 }
36391 arg1 = reinterpret_cast< wxWindow * >(argp1);
36392 ecode2 = SWIG_AsVal_int(obj1, &val2);
36393 if (!SWIG_IsOK(ecode2)) {
36394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36395 }
36396 arg2 = static_cast< int >(val2);
36397 ecode3 = SWIG_AsVal_int(obj2, &val3);
36398 if (!SWIG_IsOK(ecode3)) {
36399 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36400 }
36401 arg3 = static_cast< int >(val3);
36402 ecode4 = SWIG_AsVal_int(obj3, &val4);
36403 if (!SWIG_IsOK(ecode4)) {
36404 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36405 }
36406 arg4 = static_cast< int >(val4);
36407 ecode5 = SWIG_AsVal_int(obj4, &val5);
36408 if (!SWIG_IsOK(ecode5)) {
36409 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36410 }
36411 arg5 = static_cast< int >(val5);
36412 if (obj5) {
36413 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36414 if (!SWIG_IsOK(ecode6)) {
36415 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36416 }
36417 arg6 = static_cast< bool >(val6);
36418 }
36419 {
36420 PyThreadState* __tstate = wxPyBeginAllowThreads();
36421 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36422 wxPyEndAllowThreads(__tstate);
36423 if (PyErr_Occurred()) SWIG_fail;
36424 }
36425 resultobj = SWIG_Py_Void();
36426 return resultobj;
36427 fail:
36428 return NULL;
36429 }
36430
36431
36432 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36433 PyObject *resultobj = 0;
36434 wxWindow *arg1 = (wxWindow *) 0 ;
36435 int arg2 ;
36436 int arg3 ;
36437 bool arg4 = (bool) true ;
36438 void *argp1 = 0 ;
36439 int res1 = 0 ;
36440 int val2 ;
36441 int ecode2 = 0 ;
36442 int val3 ;
36443 int ecode3 = 0 ;
36444 bool val4 ;
36445 int ecode4 = 0 ;
36446 PyObject * obj0 = 0 ;
36447 PyObject * obj1 = 0 ;
36448 PyObject * obj2 = 0 ;
36449 PyObject * obj3 = 0 ;
36450 char * kwnames[] = {
36451 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36452 };
36453
36454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36456 if (!SWIG_IsOK(res1)) {
36457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36458 }
36459 arg1 = reinterpret_cast< wxWindow * >(argp1);
36460 ecode2 = SWIG_AsVal_int(obj1, &val2);
36461 if (!SWIG_IsOK(ecode2)) {
36462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36463 }
36464 arg2 = static_cast< int >(val2);
36465 ecode3 = SWIG_AsVal_int(obj2, &val3);
36466 if (!SWIG_IsOK(ecode3)) {
36467 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36468 }
36469 arg3 = static_cast< int >(val3);
36470 if (obj3) {
36471 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36472 if (!SWIG_IsOK(ecode4)) {
36473 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36474 }
36475 arg4 = static_cast< bool >(val4);
36476 }
36477 {
36478 PyThreadState* __tstate = wxPyBeginAllowThreads();
36479 (arg1)->SetScrollPos(arg2,arg3,arg4);
36480 wxPyEndAllowThreads(__tstate);
36481 if (PyErr_Occurred()) SWIG_fail;
36482 }
36483 resultobj = SWIG_Py_Void();
36484 return resultobj;
36485 fail:
36486 return NULL;
36487 }
36488
36489
36490 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36491 PyObject *resultobj = 0;
36492 wxWindow *arg1 = (wxWindow *) 0 ;
36493 int arg2 ;
36494 int result;
36495 void *argp1 = 0 ;
36496 int res1 = 0 ;
36497 int val2 ;
36498 int ecode2 = 0 ;
36499 PyObject * obj0 = 0 ;
36500 PyObject * obj1 = 0 ;
36501 char * kwnames[] = {
36502 (char *) "self",(char *) "orientation", NULL
36503 };
36504
36505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36507 if (!SWIG_IsOK(res1)) {
36508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36509 }
36510 arg1 = reinterpret_cast< wxWindow * >(argp1);
36511 ecode2 = SWIG_AsVal_int(obj1, &val2);
36512 if (!SWIG_IsOK(ecode2)) {
36513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36514 }
36515 arg2 = static_cast< int >(val2);
36516 {
36517 PyThreadState* __tstate = wxPyBeginAllowThreads();
36518 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36519 wxPyEndAllowThreads(__tstate);
36520 if (PyErr_Occurred()) SWIG_fail;
36521 }
36522 resultobj = SWIG_From_int(static_cast< int >(result));
36523 return resultobj;
36524 fail:
36525 return NULL;
36526 }
36527
36528
36529 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36530 PyObject *resultobj = 0;
36531 wxWindow *arg1 = (wxWindow *) 0 ;
36532 int arg2 ;
36533 int result;
36534 void *argp1 = 0 ;
36535 int res1 = 0 ;
36536 int val2 ;
36537 int ecode2 = 0 ;
36538 PyObject * obj0 = 0 ;
36539 PyObject * obj1 = 0 ;
36540 char * kwnames[] = {
36541 (char *) "self",(char *) "orientation", NULL
36542 };
36543
36544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36546 if (!SWIG_IsOK(res1)) {
36547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36548 }
36549 arg1 = reinterpret_cast< wxWindow * >(argp1);
36550 ecode2 = SWIG_AsVal_int(obj1, &val2);
36551 if (!SWIG_IsOK(ecode2)) {
36552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36553 }
36554 arg2 = static_cast< int >(val2);
36555 {
36556 PyThreadState* __tstate = wxPyBeginAllowThreads();
36557 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36558 wxPyEndAllowThreads(__tstate);
36559 if (PyErr_Occurred()) SWIG_fail;
36560 }
36561 resultobj = SWIG_From_int(static_cast< int >(result));
36562 return resultobj;
36563 fail:
36564 return NULL;
36565 }
36566
36567
36568 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36569 PyObject *resultobj = 0;
36570 wxWindow *arg1 = (wxWindow *) 0 ;
36571 int arg2 ;
36572 int result;
36573 void *argp1 = 0 ;
36574 int res1 = 0 ;
36575 int val2 ;
36576 int ecode2 = 0 ;
36577 PyObject * obj0 = 0 ;
36578 PyObject * obj1 = 0 ;
36579 char * kwnames[] = {
36580 (char *) "self",(char *) "orientation", NULL
36581 };
36582
36583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36585 if (!SWIG_IsOK(res1)) {
36586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36587 }
36588 arg1 = reinterpret_cast< wxWindow * >(argp1);
36589 ecode2 = SWIG_AsVal_int(obj1, &val2);
36590 if (!SWIG_IsOK(ecode2)) {
36591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36592 }
36593 arg2 = static_cast< int >(val2);
36594 {
36595 PyThreadState* __tstate = wxPyBeginAllowThreads();
36596 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36597 wxPyEndAllowThreads(__tstate);
36598 if (PyErr_Occurred()) SWIG_fail;
36599 }
36600 resultobj = SWIG_From_int(static_cast< int >(result));
36601 return resultobj;
36602 fail:
36603 return NULL;
36604 }
36605
36606
36607 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36608 PyObject *resultobj = 0;
36609 wxWindow *arg1 = (wxWindow *) 0 ;
36610 int arg2 ;
36611 int arg3 ;
36612 wxRect *arg4 = (wxRect *) NULL ;
36613 void *argp1 = 0 ;
36614 int res1 = 0 ;
36615 int val2 ;
36616 int ecode2 = 0 ;
36617 int val3 ;
36618 int ecode3 = 0 ;
36619 void *argp4 = 0 ;
36620 int res4 = 0 ;
36621 PyObject * obj0 = 0 ;
36622 PyObject * obj1 = 0 ;
36623 PyObject * obj2 = 0 ;
36624 PyObject * obj3 = 0 ;
36625 char * kwnames[] = {
36626 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36627 };
36628
36629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36631 if (!SWIG_IsOK(res1)) {
36632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36633 }
36634 arg1 = reinterpret_cast< wxWindow * >(argp1);
36635 ecode2 = SWIG_AsVal_int(obj1, &val2);
36636 if (!SWIG_IsOK(ecode2)) {
36637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36638 }
36639 arg2 = static_cast< int >(val2);
36640 ecode3 = SWIG_AsVal_int(obj2, &val3);
36641 if (!SWIG_IsOK(ecode3)) {
36642 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36643 }
36644 arg3 = static_cast< int >(val3);
36645 if (obj3) {
36646 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36647 if (!SWIG_IsOK(res4)) {
36648 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36649 }
36650 arg4 = reinterpret_cast< wxRect * >(argp4);
36651 }
36652 {
36653 PyThreadState* __tstate = wxPyBeginAllowThreads();
36654 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36655 wxPyEndAllowThreads(__tstate);
36656 if (PyErr_Occurred()) SWIG_fail;
36657 }
36658 resultobj = SWIG_Py_Void();
36659 return resultobj;
36660 fail:
36661 return NULL;
36662 }
36663
36664
36665 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36666 PyObject *resultobj = 0;
36667 wxWindow *arg1 = (wxWindow *) 0 ;
36668 int arg2 ;
36669 bool result;
36670 void *argp1 = 0 ;
36671 int res1 = 0 ;
36672 int val2 ;
36673 int ecode2 = 0 ;
36674 PyObject * obj0 = 0 ;
36675 PyObject * obj1 = 0 ;
36676 char * kwnames[] = {
36677 (char *) "self",(char *) "lines", NULL
36678 };
36679
36680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36682 if (!SWIG_IsOK(res1)) {
36683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36684 }
36685 arg1 = reinterpret_cast< wxWindow * >(argp1);
36686 ecode2 = SWIG_AsVal_int(obj1, &val2);
36687 if (!SWIG_IsOK(ecode2)) {
36688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36689 }
36690 arg2 = static_cast< int >(val2);
36691 {
36692 PyThreadState* __tstate = wxPyBeginAllowThreads();
36693 result = (bool)(arg1)->ScrollLines(arg2);
36694 wxPyEndAllowThreads(__tstate);
36695 if (PyErr_Occurred()) SWIG_fail;
36696 }
36697 {
36698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36699 }
36700 return resultobj;
36701 fail:
36702 return NULL;
36703 }
36704
36705
36706 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36707 PyObject *resultobj = 0;
36708 wxWindow *arg1 = (wxWindow *) 0 ;
36709 int arg2 ;
36710 bool result;
36711 void *argp1 = 0 ;
36712 int res1 = 0 ;
36713 int val2 ;
36714 int ecode2 = 0 ;
36715 PyObject * obj0 = 0 ;
36716 PyObject * obj1 = 0 ;
36717 char * kwnames[] = {
36718 (char *) "self",(char *) "pages", NULL
36719 };
36720
36721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36723 if (!SWIG_IsOK(res1)) {
36724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36725 }
36726 arg1 = reinterpret_cast< wxWindow * >(argp1);
36727 ecode2 = SWIG_AsVal_int(obj1, &val2);
36728 if (!SWIG_IsOK(ecode2)) {
36729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36730 }
36731 arg2 = static_cast< int >(val2);
36732 {
36733 PyThreadState* __tstate = wxPyBeginAllowThreads();
36734 result = (bool)(arg1)->ScrollPages(arg2);
36735 wxPyEndAllowThreads(__tstate);
36736 if (PyErr_Occurred()) SWIG_fail;
36737 }
36738 {
36739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36740 }
36741 return resultobj;
36742 fail:
36743 return NULL;
36744 }
36745
36746
36747 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36748 PyObject *resultobj = 0;
36749 wxWindow *arg1 = (wxWindow *) 0 ;
36750 bool result;
36751 void *argp1 = 0 ;
36752 int res1 = 0 ;
36753 PyObject *swig_obj[1] ;
36754
36755 if (!args) SWIG_fail;
36756 swig_obj[0] = args;
36757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36758 if (!SWIG_IsOK(res1)) {
36759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36760 }
36761 arg1 = reinterpret_cast< wxWindow * >(argp1);
36762 {
36763 PyThreadState* __tstate = wxPyBeginAllowThreads();
36764 result = (bool)(arg1)->LineUp();
36765 wxPyEndAllowThreads(__tstate);
36766 if (PyErr_Occurred()) SWIG_fail;
36767 }
36768 {
36769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36770 }
36771 return resultobj;
36772 fail:
36773 return NULL;
36774 }
36775
36776
36777 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36778 PyObject *resultobj = 0;
36779 wxWindow *arg1 = (wxWindow *) 0 ;
36780 bool result;
36781 void *argp1 = 0 ;
36782 int res1 = 0 ;
36783 PyObject *swig_obj[1] ;
36784
36785 if (!args) SWIG_fail;
36786 swig_obj[0] = args;
36787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36788 if (!SWIG_IsOK(res1)) {
36789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36790 }
36791 arg1 = reinterpret_cast< wxWindow * >(argp1);
36792 {
36793 PyThreadState* __tstate = wxPyBeginAllowThreads();
36794 result = (bool)(arg1)->LineDown();
36795 wxPyEndAllowThreads(__tstate);
36796 if (PyErr_Occurred()) SWIG_fail;
36797 }
36798 {
36799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36800 }
36801 return resultobj;
36802 fail:
36803 return NULL;
36804 }
36805
36806
36807 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36808 PyObject *resultobj = 0;
36809 wxWindow *arg1 = (wxWindow *) 0 ;
36810 bool result;
36811 void *argp1 = 0 ;
36812 int res1 = 0 ;
36813 PyObject *swig_obj[1] ;
36814
36815 if (!args) SWIG_fail;
36816 swig_obj[0] = args;
36817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36818 if (!SWIG_IsOK(res1)) {
36819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36820 }
36821 arg1 = reinterpret_cast< wxWindow * >(argp1);
36822 {
36823 PyThreadState* __tstate = wxPyBeginAllowThreads();
36824 result = (bool)(arg1)->PageUp();
36825 wxPyEndAllowThreads(__tstate);
36826 if (PyErr_Occurred()) SWIG_fail;
36827 }
36828 {
36829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36830 }
36831 return resultobj;
36832 fail:
36833 return NULL;
36834 }
36835
36836
36837 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36838 PyObject *resultobj = 0;
36839 wxWindow *arg1 = (wxWindow *) 0 ;
36840 bool result;
36841 void *argp1 = 0 ;
36842 int res1 = 0 ;
36843 PyObject *swig_obj[1] ;
36844
36845 if (!args) SWIG_fail;
36846 swig_obj[0] = args;
36847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36848 if (!SWIG_IsOK(res1)) {
36849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36850 }
36851 arg1 = reinterpret_cast< wxWindow * >(argp1);
36852 {
36853 PyThreadState* __tstate = wxPyBeginAllowThreads();
36854 result = (bool)(arg1)->PageDown();
36855 wxPyEndAllowThreads(__tstate);
36856 if (PyErr_Occurred()) SWIG_fail;
36857 }
36858 {
36859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36860 }
36861 return resultobj;
36862 fail:
36863 return NULL;
36864 }
36865
36866
36867 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36868 PyObject *resultobj = 0;
36869 wxWindow *arg1 = (wxWindow *) 0 ;
36870 wxString *arg2 = 0 ;
36871 void *argp1 = 0 ;
36872 int res1 = 0 ;
36873 bool temp2 = false ;
36874 PyObject * obj0 = 0 ;
36875 PyObject * obj1 = 0 ;
36876 char * kwnames[] = {
36877 (char *) "self",(char *) "text", NULL
36878 };
36879
36880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36882 if (!SWIG_IsOK(res1)) {
36883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36884 }
36885 arg1 = reinterpret_cast< wxWindow * >(argp1);
36886 {
36887 arg2 = wxString_in_helper(obj1);
36888 if (arg2 == NULL) SWIG_fail;
36889 temp2 = true;
36890 }
36891 {
36892 PyThreadState* __tstate = wxPyBeginAllowThreads();
36893 (arg1)->SetHelpText((wxString const &)*arg2);
36894 wxPyEndAllowThreads(__tstate);
36895 if (PyErr_Occurred()) SWIG_fail;
36896 }
36897 resultobj = SWIG_Py_Void();
36898 {
36899 if (temp2)
36900 delete arg2;
36901 }
36902 return resultobj;
36903 fail:
36904 {
36905 if (temp2)
36906 delete arg2;
36907 }
36908 return NULL;
36909 }
36910
36911
36912 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36913 PyObject *resultobj = 0;
36914 wxWindow *arg1 = (wxWindow *) 0 ;
36915 wxString *arg2 = 0 ;
36916 void *argp1 = 0 ;
36917 int res1 = 0 ;
36918 bool temp2 = false ;
36919 PyObject * obj0 = 0 ;
36920 PyObject * obj1 = 0 ;
36921 char * kwnames[] = {
36922 (char *) "self",(char *) "text", NULL
36923 };
36924
36925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36927 if (!SWIG_IsOK(res1)) {
36928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36929 }
36930 arg1 = reinterpret_cast< wxWindow * >(argp1);
36931 {
36932 arg2 = wxString_in_helper(obj1);
36933 if (arg2 == NULL) SWIG_fail;
36934 temp2 = true;
36935 }
36936 {
36937 PyThreadState* __tstate = wxPyBeginAllowThreads();
36938 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36939 wxPyEndAllowThreads(__tstate);
36940 if (PyErr_Occurred()) SWIG_fail;
36941 }
36942 resultobj = SWIG_Py_Void();
36943 {
36944 if (temp2)
36945 delete arg2;
36946 }
36947 return resultobj;
36948 fail:
36949 {
36950 if (temp2)
36951 delete arg2;
36952 }
36953 return NULL;
36954 }
36955
36956
36957 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36958 PyObject *resultobj = 0;
36959 wxWindow *arg1 = (wxWindow *) 0 ;
36960 wxPoint *arg2 = 0 ;
36961 wxHelpEvent::Origin arg3 ;
36962 wxString result;
36963 void *argp1 = 0 ;
36964 int res1 = 0 ;
36965 wxPoint temp2 ;
36966 void *argp3 ;
36967 int res3 = 0 ;
36968 PyObject * obj0 = 0 ;
36969 PyObject * obj1 = 0 ;
36970 PyObject * obj2 = 0 ;
36971 char * kwnames[] = {
36972 (char *) "self",(char *) "pt",(char *) "origin", NULL
36973 };
36974
36975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36977 if (!SWIG_IsOK(res1)) {
36978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
36979 }
36980 arg1 = reinterpret_cast< wxWindow * >(argp1);
36981 {
36982 arg2 = &temp2;
36983 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36984 }
36985 {
36986 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
36987 if (!SWIG_IsOK(res3)) {
36988 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36989 }
36990 if (!argp3) {
36991 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36992 } else {
36993 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
36994 arg3 = *temp;
36995 if (SWIG_IsNewObj(res3)) delete temp;
36996 }
36997 }
36998 {
36999 PyThreadState* __tstate = wxPyBeginAllowThreads();
37000 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37001 wxPyEndAllowThreads(__tstate);
37002 if (PyErr_Occurred()) SWIG_fail;
37003 }
37004 {
37005 #if wxUSE_UNICODE
37006 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37007 #else
37008 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37009 #endif
37010 }
37011 return resultobj;
37012 fail:
37013 return NULL;
37014 }
37015
37016
37017 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37018 PyObject *resultobj = 0;
37019 wxWindow *arg1 = (wxWindow *) 0 ;
37020 wxString result;
37021 void *argp1 = 0 ;
37022 int res1 = 0 ;
37023 PyObject *swig_obj[1] ;
37024
37025 if (!args) SWIG_fail;
37026 swig_obj[0] = args;
37027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37028 if (!SWIG_IsOK(res1)) {
37029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37030 }
37031 arg1 = reinterpret_cast< wxWindow * >(argp1);
37032 {
37033 PyThreadState* __tstate = wxPyBeginAllowThreads();
37034 result = ((wxWindow const *)arg1)->GetHelpText();
37035 wxPyEndAllowThreads(__tstate);
37036 if (PyErr_Occurred()) SWIG_fail;
37037 }
37038 {
37039 #if wxUSE_UNICODE
37040 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37041 #else
37042 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37043 #endif
37044 }
37045 return resultobj;
37046 fail:
37047 return NULL;
37048 }
37049
37050
37051 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37052 PyObject *resultobj = 0;
37053 wxWindow *arg1 = (wxWindow *) 0 ;
37054 wxString *arg2 = 0 ;
37055 void *argp1 = 0 ;
37056 int res1 = 0 ;
37057 bool temp2 = false ;
37058 PyObject * obj0 = 0 ;
37059 PyObject * obj1 = 0 ;
37060 char * kwnames[] = {
37061 (char *) "self",(char *) "tip", NULL
37062 };
37063
37064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37066 if (!SWIG_IsOK(res1)) {
37067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37068 }
37069 arg1 = reinterpret_cast< wxWindow * >(argp1);
37070 {
37071 arg2 = wxString_in_helper(obj1);
37072 if (arg2 == NULL) SWIG_fail;
37073 temp2 = true;
37074 }
37075 {
37076 PyThreadState* __tstate = wxPyBeginAllowThreads();
37077 (arg1)->SetToolTip((wxString const &)*arg2);
37078 wxPyEndAllowThreads(__tstate);
37079 if (PyErr_Occurred()) SWIG_fail;
37080 }
37081 resultobj = SWIG_Py_Void();
37082 {
37083 if (temp2)
37084 delete arg2;
37085 }
37086 return resultobj;
37087 fail:
37088 {
37089 if (temp2)
37090 delete arg2;
37091 }
37092 return NULL;
37093 }
37094
37095
37096 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37097 PyObject *resultobj = 0;
37098 wxWindow *arg1 = (wxWindow *) 0 ;
37099 wxToolTip *arg2 = (wxToolTip *) 0 ;
37100 void *argp1 = 0 ;
37101 int res1 = 0 ;
37102 int res2 = 0 ;
37103 PyObject * obj0 = 0 ;
37104 PyObject * obj1 = 0 ;
37105 char * kwnames[] = {
37106 (char *) "self",(char *) "tip", NULL
37107 };
37108
37109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37111 if (!SWIG_IsOK(res1)) {
37112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37113 }
37114 arg1 = reinterpret_cast< wxWindow * >(argp1);
37115 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37116 if (!SWIG_IsOK(res2)) {
37117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37118 }
37119 {
37120 PyThreadState* __tstate = wxPyBeginAllowThreads();
37121 (arg1)->SetToolTip(arg2);
37122 wxPyEndAllowThreads(__tstate);
37123 if (PyErr_Occurred()) SWIG_fail;
37124 }
37125 resultobj = SWIG_Py_Void();
37126 return resultobj;
37127 fail:
37128 return NULL;
37129 }
37130
37131
37132 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37133 PyObject *resultobj = 0;
37134 wxWindow *arg1 = (wxWindow *) 0 ;
37135 wxToolTip *result = 0 ;
37136 void *argp1 = 0 ;
37137 int res1 = 0 ;
37138 PyObject *swig_obj[1] ;
37139
37140 if (!args) SWIG_fail;
37141 swig_obj[0] = args;
37142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37143 if (!SWIG_IsOK(res1)) {
37144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37145 }
37146 arg1 = reinterpret_cast< wxWindow * >(argp1);
37147 {
37148 PyThreadState* __tstate = wxPyBeginAllowThreads();
37149 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37150 wxPyEndAllowThreads(__tstate);
37151 if (PyErr_Occurred()) SWIG_fail;
37152 }
37153 {
37154 resultobj = wxPyMake_wxObject(result, (bool)0);
37155 }
37156 return resultobj;
37157 fail:
37158 return NULL;
37159 }
37160
37161
37162 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37163 PyObject *resultobj = 0;
37164 wxWindow *arg1 = (wxWindow *) 0 ;
37165 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37166 void *argp1 = 0 ;
37167 int res1 = 0 ;
37168 int res2 = 0 ;
37169 PyObject * obj0 = 0 ;
37170 PyObject * obj1 = 0 ;
37171 char * kwnames[] = {
37172 (char *) "self",(char *) "dropTarget", NULL
37173 };
37174
37175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37177 if (!SWIG_IsOK(res1)) {
37178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37179 }
37180 arg1 = reinterpret_cast< wxWindow * >(argp1);
37181 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37182 if (!SWIG_IsOK(res2)) {
37183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37184 }
37185 {
37186 PyThreadState* __tstate = wxPyBeginAllowThreads();
37187 (arg1)->SetDropTarget(arg2);
37188 wxPyEndAllowThreads(__tstate);
37189 if (PyErr_Occurred()) SWIG_fail;
37190 }
37191 resultobj = SWIG_Py_Void();
37192 return resultobj;
37193 fail:
37194 return NULL;
37195 }
37196
37197
37198 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37199 PyObject *resultobj = 0;
37200 wxWindow *arg1 = (wxWindow *) 0 ;
37201 wxPyDropTarget *result = 0 ;
37202 void *argp1 = 0 ;
37203 int res1 = 0 ;
37204 PyObject *swig_obj[1] ;
37205
37206 if (!args) SWIG_fail;
37207 swig_obj[0] = args;
37208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37209 if (!SWIG_IsOK(res1)) {
37210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37211 }
37212 arg1 = reinterpret_cast< wxWindow * >(argp1);
37213 {
37214 PyThreadState* __tstate = wxPyBeginAllowThreads();
37215 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37216 wxPyEndAllowThreads(__tstate);
37217 if (PyErr_Occurred()) SWIG_fail;
37218 }
37219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37220 return resultobj;
37221 fail:
37222 return NULL;
37223 }
37224
37225
37226 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37227 PyObject *resultobj = 0;
37228 wxWindow *arg1 = (wxWindow *) 0 ;
37229 bool arg2 ;
37230 void *argp1 = 0 ;
37231 int res1 = 0 ;
37232 bool val2 ;
37233 int ecode2 = 0 ;
37234 PyObject * obj0 = 0 ;
37235 PyObject * obj1 = 0 ;
37236 char * kwnames[] = {
37237 (char *) "self",(char *) "accept", NULL
37238 };
37239
37240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37242 if (!SWIG_IsOK(res1)) {
37243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37244 }
37245 arg1 = reinterpret_cast< wxWindow * >(argp1);
37246 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37247 if (!SWIG_IsOK(ecode2)) {
37248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37249 }
37250 arg2 = static_cast< bool >(val2);
37251 {
37252 PyThreadState* __tstate = wxPyBeginAllowThreads();
37253 (arg1)->DragAcceptFiles(arg2);
37254 wxPyEndAllowThreads(__tstate);
37255 if (PyErr_Occurred()) SWIG_fail;
37256 }
37257 resultobj = SWIG_Py_Void();
37258 return resultobj;
37259 fail:
37260 return NULL;
37261 }
37262
37263
37264 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37265 PyObject *resultobj = 0;
37266 wxWindow *arg1 = (wxWindow *) 0 ;
37267 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37268 void *argp1 = 0 ;
37269 int res1 = 0 ;
37270 int res2 = 0 ;
37271 PyObject * obj0 = 0 ;
37272 PyObject * obj1 = 0 ;
37273 char * kwnames[] = {
37274 (char *) "self",(char *) "constraints", NULL
37275 };
37276
37277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37279 if (!SWIG_IsOK(res1)) {
37280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37281 }
37282 arg1 = reinterpret_cast< wxWindow * >(argp1);
37283 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37284 if (!SWIG_IsOK(res2)) {
37285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37286 }
37287 {
37288 PyThreadState* __tstate = wxPyBeginAllowThreads();
37289 (arg1)->SetConstraints(arg2);
37290 wxPyEndAllowThreads(__tstate);
37291 if (PyErr_Occurred()) SWIG_fail;
37292 }
37293 resultobj = SWIG_Py_Void();
37294 return resultobj;
37295 fail:
37296 return NULL;
37297 }
37298
37299
37300 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37301 PyObject *resultobj = 0;
37302 wxWindow *arg1 = (wxWindow *) 0 ;
37303 wxLayoutConstraints *result = 0 ;
37304 void *argp1 = 0 ;
37305 int res1 = 0 ;
37306 PyObject *swig_obj[1] ;
37307
37308 if (!args) SWIG_fail;
37309 swig_obj[0] = args;
37310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37311 if (!SWIG_IsOK(res1)) {
37312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37313 }
37314 arg1 = reinterpret_cast< wxWindow * >(argp1);
37315 {
37316 PyThreadState* __tstate = wxPyBeginAllowThreads();
37317 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37318 wxPyEndAllowThreads(__tstate);
37319 if (PyErr_Occurred()) SWIG_fail;
37320 }
37321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37322 return resultobj;
37323 fail:
37324 return NULL;
37325 }
37326
37327
37328 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37329 PyObject *resultobj = 0;
37330 wxWindow *arg1 = (wxWindow *) 0 ;
37331 bool arg2 ;
37332 void *argp1 = 0 ;
37333 int res1 = 0 ;
37334 bool val2 ;
37335 int ecode2 = 0 ;
37336 PyObject * obj0 = 0 ;
37337 PyObject * obj1 = 0 ;
37338 char * kwnames[] = {
37339 (char *) "self",(char *) "autoLayout", NULL
37340 };
37341
37342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37344 if (!SWIG_IsOK(res1)) {
37345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37346 }
37347 arg1 = reinterpret_cast< wxWindow * >(argp1);
37348 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37349 if (!SWIG_IsOK(ecode2)) {
37350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37351 }
37352 arg2 = static_cast< bool >(val2);
37353 {
37354 PyThreadState* __tstate = wxPyBeginAllowThreads();
37355 (arg1)->SetAutoLayout(arg2);
37356 wxPyEndAllowThreads(__tstate);
37357 if (PyErr_Occurred()) SWIG_fail;
37358 }
37359 resultobj = SWIG_Py_Void();
37360 return resultobj;
37361 fail:
37362 return NULL;
37363 }
37364
37365
37366 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37367 PyObject *resultobj = 0;
37368 wxWindow *arg1 = (wxWindow *) 0 ;
37369 bool result;
37370 void *argp1 = 0 ;
37371 int res1 = 0 ;
37372 PyObject *swig_obj[1] ;
37373
37374 if (!args) SWIG_fail;
37375 swig_obj[0] = args;
37376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37377 if (!SWIG_IsOK(res1)) {
37378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37379 }
37380 arg1 = reinterpret_cast< wxWindow * >(argp1);
37381 {
37382 PyThreadState* __tstate = wxPyBeginAllowThreads();
37383 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37384 wxPyEndAllowThreads(__tstate);
37385 if (PyErr_Occurred()) SWIG_fail;
37386 }
37387 {
37388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37389 }
37390 return resultobj;
37391 fail:
37392 return NULL;
37393 }
37394
37395
37396 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37397 PyObject *resultobj = 0;
37398 wxWindow *arg1 = (wxWindow *) 0 ;
37399 bool result;
37400 void *argp1 = 0 ;
37401 int res1 = 0 ;
37402 PyObject *swig_obj[1] ;
37403
37404 if (!args) SWIG_fail;
37405 swig_obj[0] = args;
37406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37407 if (!SWIG_IsOK(res1)) {
37408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37409 }
37410 arg1 = reinterpret_cast< wxWindow * >(argp1);
37411 {
37412 PyThreadState* __tstate = wxPyBeginAllowThreads();
37413 result = (bool)(arg1)->Layout();
37414 wxPyEndAllowThreads(__tstate);
37415 if (PyErr_Occurred()) SWIG_fail;
37416 }
37417 {
37418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37419 }
37420 return resultobj;
37421 fail:
37422 return NULL;
37423 }
37424
37425
37426 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37427 PyObject *resultobj = 0;
37428 wxWindow *arg1 = (wxWindow *) 0 ;
37429 wxSizer *arg2 = (wxSizer *) 0 ;
37430 bool arg3 = (bool) true ;
37431 void *argp1 = 0 ;
37432 int res1 = 0 ;
37433 int res2 = 0 ;
37434 bool val3 ;
37435 int ecode3 = 0 ;
37436 PyObject * obj0 = 0 ;
37437 PyObject * obj1 = 0 ;
37438 PyObject * obj2 = 0 ;
37439 char * kwnames[] = {
37440 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37441 };
37442
37443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37445 if (!SWIG_IsOK(res1)) {
37446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37447 }
37448 arg1 = reinterpret_cast< wxWindow * >(argp1);
37449 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37450 if (!SWIG_IsOK(res2)) {
37451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37452 }
37453 if (obj2) {
37454 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37455 if (!SWIG_IsOK(ecode3)) {
37456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37457 }
37458 arg3 = static_cast< bool >(val3);
37459 }
37460 {
37461 PyThreadState* __tstate = wxPyBeginAllowThreads();
37462 (arg1)->SetSizer(arg2,arg3);
37463 wxPyEndAllowThreads(__tstate);
37464 if (PyErr_Occurred()) SWIG_fail;
37465 }
37466 resultobj = SWIG_Py_Void();
37467 return resultobj;
37468 fail:
37469 return NULL;
37470 }
37471
37472
37473 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37474 PyObject *resultobj = 0;
37475 wxWindow *arg1 = (wxWindow *) 0 ;
37476 wxSizer *arg2 = (wxSizer *) 0 ;
37477 bool arg3 = (bool) true ;
37478 void *argp1 = 0 ;
37479 int res1 = 0 ;
37480 int res2 = 0 ;
37481 bool val3 ;
37482 int ecode3 = 0 ;
37483 PyObject * obj0 = 0 ;
37484 PyObject * obj1 = 0 ;
37485 PyObject * obj2 = 0 ;
37486 char * kwnames[] = {
37487 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37488 };
37489
37490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37492 if (!SWIG_IsOK(res1)) {
37493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37494 }
37495 arg1 = reinterpret_cast< wxWindow * >(argp1);
37496 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37497 if (!SWIG_IsOK(res2)) {
37498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37499 }
37500 if (obj2) {
37501 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37502 if (!SWIG_IsOK(ecode3)) {
37503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37504 }
37505 arg3 = static_cast< bool >(val3);
37506 }
37507 {
37508 PyThreadState* __tstate = wxPyBeginAllowThreads();
37509 (arg1)->SetSizerAndFit(arg2,arg3);
37510 wxPyEndAllowThreads(__tstate);
37511 if (PyErr_Occurred()) SWIG_fail;
37512 }
37513 resultobj = SWIG_Py_Void();
37514 return resultobj;
37515 fail:
37516 return NULL;
37517 }
37518
37519
37520 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37521 PyObject *resultobj = 0;
37522 wxWindow *arg1 = (wxWindow *) 0 ;
37523 wxSizer *result = 0 ;
37524 void *argp1 = 0 ;
37525 int res1 = 0 ;
37526 PyObject *swig_obj[1] ;
37527
37528 if (!args) SWIG_fail;
37529 swig_obj[0] = args;
37530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37531 if (!SWIG_IsOK(res1)) {
37532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37533 }
37534 arg1 = reinterpret_cast< wxWindow * >(argp1);
37535 {
37536 PyThreadState* __tstate = wxPyBeginAllowThreads();
37537 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37538 wxPyEndAllowThreads(__tstate);
37539 if (PyErr_Occurred()) SWIG_fail;
37540 }
37541 {
37542 resultobj = wxPyMake_wxObject(result, (bool)0);
37543 }
37544 return resultobj;
37545 fail:
37546 return NULL;
37547 }
37548
37549
37550 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37551 PyObject *resultobj = 0;
37552 wxWindow *arg1 = (wxWindow *) 0 ;
37553 wxSizer *arg2 = (wxSizer *) 0 ;
37554 void *argp1 = 0 ;
37555 int res1 = 0 ;
37556 void *argp2 = 0 ;
37557 int res2 = 0 ;
37558 PyObject * obj0 = 0 ;
37559 PyObject * obj1 = 0 ;
37560 char * kwnames[] = {
37561 (char *) "self",(char *) "sizer", NULL
37562 };
37563
37564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37566 if (!SWIG_IsOK(res1)) {
37567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37568 }
37569 arg1 = reinterpret_cast< wxWindow * >(argp1);
37570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37571 if (!SWIG_IsOK(res2)) {
37572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37573 }
37574 arg2 = reinterpret_cast< wxSizer * >(argp2);
37575 {
37576 PyThreadState* __tstate = wxPyBeginAllowThreads();
37577 (arg1)->SetContainingSizer(arg2);
37578 wxPyEndAllowThreads(__tstate);
37579 if (PyErr_Occurred()) SWIG_fail;
37580 }
37581 resultobj = SWIG_Py_Void();
37582 return resultobj;
37583 fail:
37584 return NULL;
37585 }
37586
37587
37588 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37589 PyObject *resultobj = 0;
37590 wxWindow *arg1 = (wxWindow *) 0 ;
37591 wxSizer *result = 0 ;
37592 void *argp1 = 0 ;
37593 int res1 = 0 ;
37594 PyObject *swig_obj[1] ;
37595
37596 if (!args) SWIG_fail;
37597 swig_obj[0] = args;
37598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37599 if (!SWIG_IsOK(res1)) {
37600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37601 }
37602 arg1 = reinterpret_cast< wxWindow * >(argp1);
37603 {
37604 PyThreadState* __tstate = wxPyBeginAllowThreads();
37605 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37606 wxPyEndAllowThreads(__tstate);
37607 if (PyErr_Occurred()) SWIG_fail;
37608 }
37609 {
37610 resultobj = wxPyMake_wxObject(result, (bool)0);
37611 }
37612 return resultobj;
37613 fail:
37614 return NULL;
37615 }
37616
37617
37618 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37619 PyObject *resultobj = 0;
37620 wxWindow *arg1 = (wxWindow *) 0 ;
37621 void *argp1 = 0 ;
37622 int res1 = 0 ;
37623 PyObject *swig_obj[1] ;
37624
37625 if (!args) SWIG_fail;
37626 swig_obj[0] = args;
37627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37628 if (!SWIG_IsOK(res1)) {
37629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37630 }
37631 arg1 = reinterpret_cast< wxWindow * >(argp1);
37632 {
37633 PyThreadState* __tstate = wxPyBeginAllowThreads();
37634 (arg1)->InheritAttributes();
37635 wxPyEndAllowThreads(__tstate);
37636 if (PyErr_Occurred()) SWIG_fail;
37637 }
37638 resultobj = SWIG_Py_Void();
37639 return resultobj;
37640 fail:
37641 return NULL;
37642 }
37643
37644
37645 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37646 PyObject *resultobj = 0;
37647 wxWindow *arg1 = (wxWindow *) 0 ;
37648 bool result;
37649 void *argp1 = 0 ;
37650 int res1 = 0 ;
37651 PyObject *swig_obj[1] ;
37652
37653 if (!args) SWIG_fail;
37654 swig_obj[0] = args;
37655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37656 if (!SWIG_IsOK(res1)) {
37657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37658 }
37659 arg1 = reinterpret_cast< wxWindow * >(argp1);
37660 {
37661 PyThreadState* __tstate = wxPyBeginAllowThreads();
37662 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37663 wxPyEndAllowThreads(__tstate);
37664 if (PyErr_Occurred()) SWIG_fail;
37665 }
37666 {
37667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37668 }
37669 return resultobj;
37670 fail:
37671 return NULL;
37672 }
37673
37674
37675 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37676 PyObject *obj;
37677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37678 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37679 return SWIG_Py_Void();
37680 }
37681
37682 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37683 return SWIG_Python_InitShadowInstance(args);
37684 }
37685
37686 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37687 PyObject *resultobj = 0;
37688 long arg1 ;
37689 wxWindow *arg2 = (wxWindow *) NULL ;
37690 wxWindow *result = 0 ;
37691 long val1 ;
37692 int ecode1 = 0 ;
37693 void *argp2 = 0 ;
37694 int res2 = 0 ;
37695 PyObject * obj0 = 0 ;
37696 PyObject * obj1 = 0 ;
37697 char * kwnames[] = {
37698 (char *) "id",(char *) "parent", NULL
37699 };
37700
37701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37702 ecode1 = SWIG_AsVal_long(obj0, &val1);
37703 if (!SWIG_IsOK(ecode1)) {
37704 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37705 }
37706 arg1 = static_cast< long >(val1);
37707 if (obj1) {
37708 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37709 if (!SWIG_IsOK(res2)) {
37710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37711 }
37712 arg2 = reinterpret_cast< wxWindow * >(argp2);
37713 }
37714 {
37715 if (!wxPyCheckForApp()) SWIG_fail;
37716 PyThreadState* __tstate = wxPyBeginAllowThreads();
37717 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37718 wxPyEndAllowThreads(__tstate);
37719 if (PyErr_Occurred()) SWIG_fail;
37720 }
37721 {
37722 resultobj = wxPyMake_wxObject(result, 0);
37723 }
37724 return resultobj;
37725 fail:
37726 return NULL;
37727 }
37728
37729
37730 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37731 PyObject *resultobj = 0;
37732 wxString *arg1 = 0 ;
37733 wxWindow *arg2 = (wxWindow *) NULL ;
37734 wxWindow *result = 0 ;
37735 bool temp1 = false ;
37736 void *argp2 = 0 ;
37737 int res2 = 0 ;
37738 PyObject * obj0 = 0 ;
37739 PyObject * obj1 = 0 ;
37740 char * kwnames[] = {
37741 (char *) "name",(char *) "parent", NULL
37742 };
37743
37744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37745 {
37746 arg1 = wxString_in_helper(obj0);
37747 if (arg1 == NULL) SWIG_fail;
37748 temp1 = true;
37749 }
37750 if (obj1) {
37751 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37752 if (!SWIG_IsOK(res2)) {
37753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37754 }
37755 arg2 = reinterpret_cast< wxWindow * >(argp2);
37756 }
37757 {
37758 if (!wxPyCheckForApp()) SWIG_fail;
37759 PyThreadState* __tstate = wxPyBeginAllowThreads();
37760 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37761 wxPyEndAllowThreads(__tstate);
37762 if (PyErr_Occurred()) SWIG_fail;
37763 }
37764 {
37765 resultobj = wxPyMake_wxObject(result, 0);
37766 }
37767 {
37768 if (temp1)
37769 delete arg1;
37770 }
37771 return resultobj;
37772 fail:
37773 {
37774 if (temp1)
37775 delete arg1;
37776 }
37777 return NULL;
37778 }
37779
37780
37781 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37782 PyObject *resultobj = 0;
37783 wxString *arg1 = 0 ;
37784 wxWindow *arg2 = (wxWindow *) NULL ;
37785 wxWindow *result = 0 ;
37786 bool temp1 = false ;
37787 void *argp2 = 0 ;
37788 int res2 = 0 ;
37789 PyObject * obj0 = 0 ;
37790 PyObject * obj1 = 0 ;
37791 char * kwnames[] = {
37792 (char *) "label",(char *) "parent", NULL
37793 };
37794
37795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37796 {
37797 arg1 = wxString_in_helper(obj0);
37798 if (arg1 == NULL) SWIG_fail;
37799 temp1 = true;
37800 }
37801 if (obj1) {
37802 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37803 if (!SWIG_IsOK(res2)) {
37804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37805 }
37806 arg2 = reinterpret_cast< wxWindow * >(argp2);
37807 }
37808 {
37809 if (!wxPyCheckForApp()) SWIG_fail;
37810 PyThreadState* __tstate = wxPyBeginAllowThreads();
37811 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37812 wxPyEndAllowThreads(__tstate);
37813 if (PyErr_Occurred()) SWIG_fail;
37814 }
37815 {
37816 resultobj = wxPyMake_wxObject(result, 0);
37817 }
37818 {
37819 if (temp1)
37820 delete arg1;
37821 }
37822 return resultobj;
37823 fail:
37824 {
37825 if (temp1)
37826 delete arg1;
37827 }
37828 return NULL;
37829 }
37830
37831
37832 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37833 PyObject *resultobj = 0;
37834 wxWindow *arg1 = (wxWindow *) 0 ;
37835 unsigned long arg2 ;
37836 wxWindow *result = 0 ;
37837 void *argp1 = 0 ;
37838 int res1 = 0 ;
37839 unsigned long val2 ;
37840 int ecode2 = 0 ;
37841 PyObject * obj0 = 0 ;
37842 PyObject * obj1 = 0 ;
37843 char * kwnames[] = {
37844 (char *) "parent",(char *) "_hWnd", NULL
37845 };
37846
37847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37849 if (!SWIG_IsOK(res1)) {
37850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37851 }
37852 arg1 = reinterpret_cast< wxWindow * >(argp1);
37853 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37854 if (!SWIG_IsOK(ecode2)) {
37855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37856 }
37857 arg2 = static_cast< unsigned long >(val2);
37858 {
37859 PyThreadState* __tstate = wxPyBeginAllowThreads();
37860 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37861 wxPyEndAllowThreads(__tstate);
37862 if (PyErr_Occurred()) SWIG_fail;
37863 }
37864 {
37865 resultobj = wxPyMake_wxObject(result, 0);
37866 }
37867 return resultobj;
37868 fail:
37869 return NULL;
37870 }
37871
37872
37873 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37874 PyObject *resultobj = 0;
37875 PyObject *result = 0 ;
37876
37877 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37878 {
37879 PyThreadState* __tstate = wxPyBeginAllowThreads();
37880 result = (PyObject *)GetTopLevelWindows();
37881 wxPyEndAllowThreads(__tstate);
37882 if (PyErr_Occurred()) SWIG_fail;
37883 }
37884 resultobj = result;
37885 return resultobj;
37886 fail:
37887 return NULL;
37888 }
37889
37890
37891 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37892 PyObject *resultobj = 0;
37893 wxValidator *result = 0 ;
37894
37895 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37896 {
37897 PyThreadState* __tstate = wxPyBeginAllowThreads();
37898 result = (wxValidator *)new wxValidator();
37899 wxPyEndAllowThreads(__tstate);
37900 if (PyErr_Occurred()) SWIG_fail;
37901 }
37902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37903 return resultobj;
37904 fail:
37905 return NULL;
37906 }
37907
37908
37909 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37910 PyObject *resultobj = 0;
37911 wxValidator *arg1 = (wxValidator *) 0 ;
37912 wxValidator *result = 0 ;
37913 void *argp1 = 0 ;
37914 int res1 = 0 ;
37915 PyObject *swig_obj[1] ;
37916
37917 if (!args) SWIG_fail;
37918 swig_obj[0] = args;
37919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37920 if (!SWIG_IsOK(res1)) {
37921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37922 }
37923 arg1 = reinterpret_cast< wxValidator * >(argp1);
37924 {
37925 PyThreadState* __tstate = wxPyBeginAllowThreads();
37926 result = (wxValidator *)(arg1)->Clone();
37927 wxPyEndAllowThreads(__tstate);
37928 if (PyErr_Occurred()) SWIG_fail;
37929 }
37930 {
37931 resultobj = wxPyMake_wxObject(result, 0);
37932 }
37933 return resultobj;
37934 fail:
37935 return NULL;
37936 }
37937
37938
37939 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37940 PyObject *resultobj = 0;
37941 wxValidator *arg1 = (wxValidator *) 0 ;
37942 wxWindow *arg2 = (wxWindow *) 0 ;
37943 bool result;
37944 void *argp1 = 0 ;
37945 int res1 = 0 ;
37946 void *argp2 = 0 ;
37947 int res2 = 0 ;
37948 PyObject * obj0 = 0 ;
37949 PyObject * obj1 = 0 ;
37950 char * kwnames[] = {
37951 (char *) "self",(char *) "parent", NULL
37952 };
37953
37954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37956 if (!SWIG_IsOK(res1)) {
37957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37958 }
37959 arg1 = reinterpret_cast< wxValidator * >(argp1);
37960 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37961 if (!SWIG_IsOK(res2)) {
37962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37963 }
37964 arg2 = reinterpret_cast< wxWindow * >(argp2);
37965 {
37966 PyThreadState* __tstate = wxPyBeginAllowThreads();
37967 result = (bool)(arg1)->Validate(arg2);
37968 wxPyEndAllowThreads(__tstate);
37969 if (PyErr_Occurred()) SWIG_fail;
37970 }
37971 {
37972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37973 }
37974 return resultobj;
37975 fail:
37976 return NULL;
37977 }
37978
37979
37980 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37981 PyObject *resultobj = 0;
37982 wxValidator *arg1 = (wxValidator *) 0 ;
37983 bool result;
37984 void *argp1 = 0 ;
37985 int res1 = 0 ;
37986 PyObject *swig_obj[1] ;
37987
37988 if (!args) SWIG_fail;
37989 swig_obj[0] = args;
37990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37991 if (!SWIG_IsOK(res1)) {
37992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37993 }
37994 arg1 = reinterpret_cast< wxValidator * >(argp1);
37995 {
37996 PyThreadState* __tstate = wxPyBeginAllowThreads();
37997 result = (bool)(arg1)->TransferToWindow();
37998 wxPyEndAllowThreads(__tstate);
37999 if (PyErr_Occurred()) SWIG_fail;
38000 }
38001 {
38002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38003 }
38004 return resultobj;
38005 fail:
38006 return NULL;
38007 }
38008
38009
38010 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38011 PyObject *resultobj = 0;
38012 wxValidator *arg1 = (wxValidator *) 0 ;
38013 bool result;
38014 void *argp1 = 0 ;
38015 int res1 = 0 ;
38016 PyObject *swig_obj[1] ;
38017
38018 if (!args) SWIG_fail;
38019 swig_obj[0] = args;
38020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38021 if (!SWIG_IsOK(res1)) {
38022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38023 }
38024 arg1 = reinterpret_cast< wxValidator * >(argp1);
38025 {
38026 PyThreadState* __tstate = wxPyBeginAllowThreads();
38027 result = (bool)(arg1)->TransferFromWindow();
38028 wxPyEndAllowThreads(__tstate);
38029 if (PyErr_Occurred()) SWIG_fail;
38030 }
38031 {
38032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38033 }
38034 return resultobj;
38035 fail:
38036 return NULL;
38037 }
38038
38039
38040 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38041 PyObject *resultobj = 0;
38042 wxValidator *arg1 = (wxValidator *) 0 ;
38043 wxWindow *result = 0 ;
38044 void *argp1 = 0 ;
38045 int res1 = 0 ;
38046 PyObject *swig_obj[1] ;
38047
38048 if (!args) SWIG_fail;
38049 swig_obj[0] = args;
38050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38051 if (!SWIG_IsOK(res1)) {
38052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38053 }
38054 arg1 = reinterpret_cast< wxValidator * >(argp1);
38055 {
38056 PyThreadState* __tstate = wxPyBeginAllowThreads();
38057 result = (wxWindow *)(arg1)->GetWindow();
38058 wxPyEndAllowThreads(__tstate);
38059 if (PyErr_Occurred()) SWIG_fail;
38060 }
38061 {
38062 resultobj = wxPyMake_wxObject(result, 0);
38063 }
38064 return resultobj;
38065 fail:
38066 return NULL;
38067 }
38068
38069
38070 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38071 PyObject *resultobj = 0;
38072 wxValidator *arg1 = (wxValidator *) 0 ;
38073 wxWindow *arg2 = (wxWindow *) 0 ;
38074 void *argp1 = 0 ;
38075 int res1 = 0 ;
38076 void *argp2 = 0 ;
38077 int res2 = 0 ;
38078 PyObject * obj0 = 0 ;
38079 PyObject * obj1 = 0 ;
38080 char * kwnames[] = {
38081 (char *) "self",(char *) "window", NULL
38082 };
38083
38084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38086 if (!SWIG_IsOK(res1)) {
38087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38088 }
38089 arg1 = reinterpret_cast< wxValidator * >(argp1);
38090 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38091 if (!SWIG_IsOK(res2)) {
38092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38093 }
38094 arg2 = reinterpret_cast< wxWindow * >(argp2);
38095 {
38096 PyThreadState* __tstate = wxPyBeginAllowThreads();
38097 (arg1)->SetWindow(arg2);
38098 wxPyEndAllowThreads(__tstate);
38099 if (PyErr_Occurred()) SWIG_fail;
38100 }
38101 resultobj = SWIG_Py_Void();
38102 return resultobj;
38103 fail:
38104 return NULL;
38105 }
38106
38107
38108 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38109 PyObject *resultobj = 0;
38110 bool result;
38111
38112 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38113 {
38114 PyThreadState* __tstate = wxPyBeginAllowThreads();
38115 result = (bool)wxValidator::IsSilent();
38116 wxPyEndAllowThreads(__tstate);
38117 if (PyErr_Occurred()) SWIG_fail;
38118 }
38119 {
38120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38121 }
38122 return resultobj;
38123 fail:
38124 return NULL;
38125 }
38126
38127
38128 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38129 PyObject *resultobj = 0;
38130 int arg1 = (int) true ;
38131 int val1 ;
38132 int ecode1 = 0 ;
38133 PyObject * obj0 = 0 ;
38134 char * kwnames[] = {
38135 (char *) "doIt", NULL
38136 };
38137
38138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38139 if (obj0) {
38140 ecode1 = SWIG_AsVal_int(obj0, &val1);
38141 if (!SWIG_IsOK(ecode1)) {
38142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38143 }
38144 arg1 = static_cast< int >(val1);
38145 }
38146 {
38147 PyThreadState* __tstate = wxPyBeginAllowThreads();
38148 wxValidator::SetBellOnError(arg1);
38149 wxPyEndAllowThreads(__tstate);
38150 if (PyErr_Occurred()) SWIG_fail;
38151 }
38152 resultobj = SWIG_Py_Void();
38153 return resultobj;
38154 fail:
38155 return NULL;
38156 }
38157
38158
38159 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38160 PyObject *obj;
38161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38162 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38163 return SWIG_Py_Void();
38164 }
38165
38166 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38167 return SWIG_Python_InitShadowInstance(args);
38168 }
38169
38170 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38171 PyObject *resultobj = 0;
38172 wxPyValidator *result = 0 ;
38173
38174 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38175 {
38176 PyThreadState* __tstate = wxPyBeginAllowThreads();
38177 result = (wxPyValidator *)new wxPyValidator();
38178 wxPyEndAllowThreads(__tstate);
38179 if (PyErr_Occurred()) SWIG_fail;
38180 }
38181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38182 return resultobj;
38183 fail:
38184 return NULL;
38185 }
38186
38187
38188 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38189 PyObject *resultobj = 0;
38190 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38191 PyObject *arg2 = (PyObject *) 0 ;
38192 PyObject *arg3 = (PyObject *) 0 ;
38193 int arg4 = (int) true ;
38194 void *argp1 = 0 ;
38195 int res1 = 0 ;
38196 int val4 ;
38197 int ecode4 = 0 ;
38198 PyObject * obj0 = 0 ;
38199 PyObject * obj1 = 0 ;
38200 PyObject * obj2 = 0 ;
38201 PyObject * obj3 = 0 ;
38202 char * kwnames[] = {
38203 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38204 };
38205
38206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38208 if (!SWIG_IsOK(res1)) {
38209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38210 }
38211 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38212 arg2 = obj1;
38213 arg3 = obj2;
38214 if (obj3) {
38215 ecode4 = SWIG_AsVal_int(obj3, &val4);
38216 if (!SWIG_IsOK(ecode4)) {
38217 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38218 }
38219 arg4 = static_cast< int >(val4);
38220 }
38221 {
38222 PyThreadState* __tstate = wxPyBeginAllowThreads();
38223 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38224 wxPyEndAllowThreads(__tstate);
38225 if (PyErr_Occurred()) SWIG_fail;
38226 }
38227 resultobj = SWIG_Py_Void();
38228 return resultobj;
38229 fail:
38230 return NULL;
38231 }
38232
38233
38234 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38235 PyObject *obj;
38236 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38237 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38238 return SWIG_Py_Void();
38239 }
38240
38241 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38242 return SWIG_Python_InitShadowInstance(args);
38243 }
38244
38245 SWIGINTERN int DefaultValidator_set(PyObject *) {
38246 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38247 return 1;
38248 }
38249
38250
38251 SWIGINTERN PyObject *DefaultValidator_get(void) {
38252 PyObject *pyobj = 0;
38253
38254 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38255 return pyobj;
38256 }
38257
38258
38259 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38260 PyObject *resultobj = 0;
38261 wxString const &arg1_defvalue = wxPyEmptyString ;
38262 wxString *arg1 = (wxString *) &arg1_defvalue ;
38263 long arg2 = (long) 0 ;
38264 wxMenu *result = 0 ;
38265 bool temp1 = false ;
38266 long val2 ;
38267 int ecode2 = 0 ;
38268 PyObject * obj0 = 0 ;
38269 PyObject * obj1 = 0 ;
38270 char * kwnames[] = {
38271 (char *) "title",(char *) "style", NULL
38272 };
38273
38274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38275 if (obj0) {
38276 {
38277 arg1 = wxString_in_helper(obj0);
38278 if (arg1 == NULL) SWIG_fail;
38279 temp1 = true;
38280 }
38281 }
38282 if (obj1) {
38283 ecode2 = SWIG_AsVal_long(obj1, &val2);
38284 if (!SWIG_IsOK(ecode2)) {
38285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38286 }
38287 arg2 = static_cast< long >(val2);
38288 }
38289 {
38290 if (!wxPyCheckForApp()) SWIG_fail;
38291 PyThreadState* __tstate = wxPyBeginAllowThreads();
38292 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38293 wxPyEndAllowThreads(__tstate);
38294 if (PyErr_Occurred()) SWIG_fail;
38295 }
38296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38297 {
38298 if (temp1)
38299 delete arg1;
38300 }
38301 return resultobj;
38302 fail:
38303 {
38304 if (temp1)
38305 delete arg1;
38306 }
38307 return NULL;
38308 }
38309
38310
38311 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38312 PyObject *resultobj = 0;
38313 wxMenu *arg1 = (wxMenu *) 0 ;
38314 int arg2 ;
38315 wxString *arg3 = 0 ;
38316 wxString const &arg4_defvalue = wxPyEmptyString ;
38317 wxString *arg4 = (wxString *) &arg4_defvalue ;
38318 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38319 wxMenuItem *result = 0 ;
38320 void *argp1 = 0 ;
38321 int res1 = 0 ;
38322 int val2 ;
38323 int ecode2 = 0 ;
38324 bool temp3 = false ;
38325 bool temp4 = false ;
38326 int val5 ;
38327 int ecode5 = 0 ;
38328 PyObject * obj0 = 0 ;
38329 PyObject * obj1 = 0 ;
38330 PyObject * obj2 = 0 ;
38331 PyObject * obj3 = 0 ;
38332 PyObject * obj4 = 0 ;
38333 char * kwnames[] = {
38334 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38335 };
38336
38337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38339 if (!SWIG_IsOK(res1)) {
38340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38341 }
38342 arg1 = reinterpret_cast< wxMenu * >(argp1);
38343 ecode2 = SWIG_AsVal_int(obj1, &val2);
38344 if (!SWIG_IsOK(ecode2)) {
38345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38346 }
38347 arg2 = static_cast< int >(val2);
38348 {
38349 arg3 = wxString_in_helper(obj2);
38350 if (arg3 == NULL) SWIG_fail;
38351 temp3 = true;
38352 }
38353 if (obj3) {
38354 {
38355 arg4 = wxString_in_helper(obj3);
38356 if (arg4 == NULL) SWIG_fail;
38357 temp4 = true;
38358 }
38359 }
38360 if (obj4) {
38361 ecode5 = SWIG_AsVal_int(obj4, &val5);
38362 if (!SWIG_IsOK(ecode5)) {
38363 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38364 }
38365 arg5 = static_cast< wxItemKind >(val5);
38366 }
38367 {
38368 PyThreadState* __tstate = wxPyBeginAllowThreads();
38369 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38370 wxPyEndAllowThreads(__tstate);
38371 if (PyErr_Occurred()) SWIG_fail;
38372 }
38373 {
38374 resultobj = wxPyMake_wxObject(result, (bool)0);
38375 }
38376 {
38377 if (temp3)
38378 delete arg3;
38379 }
38380 {
38381 if (temp4)
38382 delete arg4;
38383 }
38384 return resultobj;
38385 fail:
38386 {
38387 if (temp3)
38388 delete arg3;
38389 }
38390 {
38391 if (temp4)
38392 delete arg4;
38393 }
38394 return NULL;
38395 }
38396
38397
38398 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38399 PyObject *resultobj = 0;
38400 wxMenu *arg1 = (wxMenu *) 0 ;
38401 wxMenuItem *result = 0 ;
38402 void *argp1 = 0 ;
38403 int res1 = 0 ;
38404 PyObject *swig_obj[1] ;
38405
38406 if (!args) SWIG_fail;
38407 swig_obj[0] = args;
38408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38409 if (!SWIG_IsOK(res1)) {
38410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38411 }
38412 arg1 = reinterpret_cast< wxMenu * >(argp1);
38413 {
38414 PyThreadState* __tstate = wxPyBeginAllowThreads();
38415 result = (wxMenuItem *)(arg1)->AppendSeparator();
38416 wxPyEndAllowThreads(__tstate);
38417 if (PyErr_Occurred()) SWIG_fail;
38418 }
38419 {
38420 resultobj = wxPyMake_wxObject(result, (bool)0);
38421 }
38422 return resultobj;
38423 fail:
38424 return NULL;
38425 }
38426
38427
38428 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38429 PyObject *resultobj = 0;
38430 wxMenu *arg1 = (wxMenu *) 0 ;
38431 int arg2 ;
38432 wxString *arg3 = 0 ;
38433 wxString const &arg4_defvalue = wxPyEmptyString ;
38434 wxString *arg4 = (wxString *) &arg4_defvalue ;
38435 wxMenuItem *result = 0 ;
38436 void *argp1 = 0 ;
38437 int res1 = 0 ;
38438 int val2 ;
38439 int ecode2 = 0 ;
38440 bool temp3 = false ;
38441 bool temp4 = false ;
38442 PyObject * obj0 = 0 ;
38443 PyObject * obj1 = 0 ;
38444 PyObject * obj2 = 0 ;
38445 PyObject * obj3 = 0 ;
38446 char * kwnames[] = {
38447 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38448 };
38449
38450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38452 if (!SWIG_IsOK(res1)) {
38453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38454 }
38455 arg1 = reinterpret_cast< wxMenu * >(argp1);
38456 ecode2 = SWIG_AsVal_int(obj1, &val2);
38457 if (!SWIG_IsOK(ecode2)) {
38458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38459 }
38460 arg2 = static_cast< int >(val2);
38461 {
38462 arg3 = wxString_in_helper(obj2);
38463 if (arg3 == NULL) SWIG_fail;
38464 temp3 = true;
38465 }
38466 if (obj3) {
38467 {
38468 arg4 = wxString_in_helper(obj3);
38469 if (arg4 == NULL) SWIG_fail;
38470 temp4 = true;
38471 }
38472 }
38473 {
38474 PyThreadState* __tstate = wxPyBeginAllowThreads();
38475 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38476 wxPyEndAllowThreads(__tstate);
38477 if (PyErr_Occurred()) SWIG_fail;
38478 }
38479 {
38480 resultobj = wxPyMake_wxObject(result, (bool)0);
38481 }
38482 {
38483 if (temp3)
38484 delete arg3;
38485 }
38486 {
38487 if (temp4)
38488 delete arg4;
38489 }
38490 return resultobj;
38491 fail:
38492 {
38493 if (temp3)
38494 delete arg3;
38495 }
38496 {
38497 if (temp4)
38498 delete arg4;
38499 }
38500 return NULL;
38501 }
38502
38503
38504 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38505 PyObject *resultobj = 0;
38506 wxMenu *arg1 = (wxMenu *) 0 ;
38507 int arg2 ;
38508 wxString *arg3 = 0 ;
38509 wxString const &arg4_defvalue = wxPyEmptyString ;
38510 wxString *arg4 = (wxString *) &arg4_defvalue ;
38511 wxMenuItem *result = 0 ;
38512 void *argp1 = 0 ;
38513 int res1 = 0 ;
38514 int val2 ;
38515 int ecode2 = 0 ;
38516 bool temp3 = false ;
38517 bool temp4 = false ;
38518 PyObject * obj0 = 0 ;
38519 PyObject * obj1 = 0 ;
38520 PyObject * obj2 = 0 ;
38521 PyObject * obj3 = 0 ;
38522 char * kwnames[] = {
38523 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38524 };
38525
38526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38528 if (!SWIG_IsOK(res1)) {
38529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38530 }
38531 arg1 = reinterpret_cast< wxMenu * >(argp1);
38532 ecode2 = SWIG_AsVal_int(obj1, &val2);
38533 if (!SWIG_IsOK(ecode2)) {
38534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38535 }
38536 arg2 = static_cast< int >(val2);
38537 {
38538 arg3 = wxString_in_helper(obj2);
38539 if (arg3 == NULL) SWIG_fail;
38540 temp3 = true;
38541 }
38542 if (obj3) {
38543 {
38544 arg4 = wxString_in_helper(obj3);
38545 if (arg4 == NULL) SWIG_fail;
38546 temp4 = true;
38547 }
38548 }
38549 {
38550 PyThreadState* __tstate = wxPyBeginAllowThreads();
38551 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38552 wxPyEndAllowThreads(__tstate);
38553 if (PyErr_Occurred()) SWIG_fail;
38554 }
38555 {
38556 resultobj = wxPyMake_wxObject(result, (bool)0);
38557 }
38558 {
38559 if (temp3)
38560 delete arg3;
38561 }
38562 {
38563 if (temp4)
38564 delete arg4;
38565 }
38566 return resultobj;
38567 fail:
38568 {
38569 if (temp3)
38570 delete arg3;
38571 }
38572 {
38573 if (temp4)
38574 delete arg4;
38575 }
38576 return NULL;
38577 }
38578
38579
38580 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38581 PyObject *resultobj = 0;
38582 wxMenu *arg1 = (wxMenu *) 0 ;
38583 int arg2 ;
38584 wxString *arg3 = 0 ;
38585 wxMenu *arg4 = (wxMenu *) 0 ;
38586 wxString const &arg5_defvalue = wxPyEmptyString ;
38587 wxString *arg5 = (wxString *) &arg5_defvalue ;
38588 wxMenuItem *result = 0 ;
38589 void *argp1 = 0 ;
38590 int res1 = 0 ;
38591 int val2 ;
38592 int ecode2 = 0 ;
38593 bool temp3 = false ;
38594 void *argp4 = 0 ;
38595 int res4 = 0 ;
38596 bool temp5 = false ;
38597 PyObject * obj0 = 0 ;
38598 PyObject * obj1 = 0 ;
38599 PyObject * obj2 = 0 ;
38600 PyObject * obj3 = 0 ;
38601 PyObject * obj4 = 0 ;
38602 char * kwnames[] = {
38603 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38604 };
38605
38606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38608 if (!SWIG_IsOK(res1)) {
38609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38610 }
38611 arg1 = reinterpret_cast< wxMenu * >(argp1);
38612 ecode2 = SWIG_AsVal_int(obj1, &val2);
38613 if (!SWIG_IsOK(ecode2)) {
38614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38615 }
38616 arg2 = static_cast< int >(val2);
38617 {
38618 arg3 = wxString_in_helper(obj2);
38619 if (arg3 == NULL) SWIG_fail;
38620 temp3 = true;
38621 }
38622 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38623 if (!SWIG_IsOK(res4)) {
38624 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38625 }
38626 arg4 = reinterpret_cast< wxMenu * >(argp4);
38627 if (obj4) {
38628 {
38629 arg5 = wxString_in_helper(obj4);
38630 if (arg5 == NULL) SWIG_fail;
38631 temp5 = true;
38632 }
38633 }
38634 {
38635 PyThreadState* __tstate = wxPyBeginAllowThreads();
38636 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38637 wxPyEndAllowThreads(__tstate);
38638 if (PyErr_Occurred()) SWIG_fail;
38639 }
38640 {
38641 resultobj = wxPyMake_wxObject(result, (bool)0);
38642 }
38643 {
38644 if (temp3)
38645 delete arg3;
38646 }
38647 {
38648 if (temp5)
38649 delete arg5;
38650 }
38651 return resultobj;
38652 fail:
38653 {
38654 if (temp3)
38655 delete arg3;
38656 }
38657 {
38658 if (temp5)
38659 delete arg5;
38660 }
38661 return NULL;
38662 }
38663
38664
38665 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38666 PyObject *resultobj = 0;
38667 wxMenu *arg1 = (wxMenu *) 0 ;
38668 wxMenu *arg2 = (wxMenu *) 0 ;
38669 wxString *arg3 = 0 ;
38670 wxString const &arg4_defvalue = wxPyEmptyString ;
38671 wxString *arg4 = (wxString *) &arg4_defvalue ;
38672 wxMenuItem *result = 0 ;
38673 void *argp1 = 0 ;
38674 int res1 = 0 ;
38675 void *argp2 = 0 ;
38676 int res2 = 0 ;
38677 bool temp3 = false ;
38678 bool temp4 = false ;
38679 PyObject * obj0 = 0 ;
38680 PyObject * obj1 = 0 ;
38681 PyObject * obj2 = 0 ;
38682 PyObject * obj3 = 0 ;
38683 char * kwnames[] = {
38684 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38685 };
38686
38687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38689 if (!SWIG_IsOK(res1)) {
38690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38691 }
38692 arg1 = reinterpret_cast< wxMenu * >(argp1);
38693 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38694 if (!SWIG_IsOK(res2)) {
38695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38696 }
38697 arg2 = reinterpret_cast< wxMenu * >(argp2);
38698 {
38699 arg3 = wxString_in_helper(obj2);
38700 if (arg3 == NULL) SWIG_fail;
38701 temp3 = true;
38702 }
38703 if (obj3) {
38704 {
38705 arg4 = wxString_in_helper(obj3);
38706 if (arg4 == NULL) SWIG_fail;
38707 temp4 = true;
38708 }
38709 }
38710 {
38711 PyThreadState* __tstate = wxPyBeginAllowThreads();
38712 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38713 wxPyEndAllowThreads(__tstate);
38714 if (PyErr_Occurred()) SWIG_fail;
38715 }
38716 {
38717 resultobj = wxPyMake_wxObject(result, (bool)0);
38718 }
38719 {
38720 if (temp3)
38721 delete arg3;
38722 }
38723 {
38724 if (temp4)
38725 delete arg4;
38726 }
38727 return resultobj;
38728 fail:
38729 {
38730 if (temp3)
38731 delete arg3;
38732 }
38733 {
38734 if (temp4)
38735 delete arg4;
38736 }
38737 return NULL;
38738 }
38739
38740
38741 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38742 PyObject *resultobj = 0;
38743 wxMenu *arg1 = (wxMenu *) 0 ;
38744 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38745 wxMenuItem *result = 0 ;
38746 void *argp1 = 0 ;
38747 int res1 = 0 ;
38748 int res2 = 0 ;
38749 PyObject * obj0 = 0 ;
38750 PyObject * obj1 = 0 ;
38751 char * kwnames[] = {
38752 (char *) "self",(char *) "item", NULL
38753 };
38754
38755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38757 if (!SWIG_IsOK(res1)) {
38758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38759 }
38760 arg1 = reinterpret_cast< wxMenu * >(argp1);
38761 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38762 if (!SWIG_IsOK(res2)) {
38763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38764 }
38765 {
38766 PyThreadState* __tstate = wxPyBeginAllowThreads();
38767 result = (wxMenuItem *)(arg1)->Append(arg2);
38768 wxPyEndAllowThreads(__tstate);
38769 if (PyErr_Occurred()) SWIG_fail;
38770 }
38771 {
38772 resultobj = wxPyMake_wxObject(result, (bool)0);
38773 }
38774 return resultobj;
38775 fail:
38776 return NULL;
38777 }
38778
38779
38780 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38781 PyObject *resultobj = 0;
38782 wxMenu *arg1 = (wxMenu *) 0 ;
38783 size_t arg2 ;
38784 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38785 wxMenuItem *result = 0 ;
38786 void *argp1 = 0 ;
38787 int res1 = 0 ;
38788 size_t val2 ;
38789 int ecode2 = 0 ;
38790 int res3 = 0 ;
38791 PyObject * obj0 = 0 ;
38792 PyObject * obj1 = 0 ;
38793 PyObject * obj2 = 0 ;
38794 char * kwnames[] = {
38795 (char *) "self",(char *) "pos",(char *) "item", NULL
38796 };
38797
38798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38800 if (!SWIG_IsOK(res1)) {
38801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38802 }
38803 arg1 = reinterpret_cast< wxMenu * >(argp1);
38804 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38805 if (!SWIG_IsOK(ecode2)) {
38806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38807 }
38808 arg2 = static_cast< size_t >(val2);
38809 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38810 if (!SWIG_IsOK(res3)) {
38811 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38812 }
38813 {
38814 PyThreadState* __tstate = wxPyBeginAllowThreads();
38815 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38816 wxPyEndAllowThreads(__tstate);
38817 if (PyErr_Occurred()) SWIG_fail;
38818 }
38819 {
38820 resultobj = wxPyMake_wxObject(result, (bool)0);
38821 }
38822 return resultobj;
38823 fail:
38824 return NULL;
38825 }
38826
38827
38828 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38829 PyObject *resultobj = 0;
38830 wxMenu *arg1 = (wxMenu *) 0 ;
38831 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38832 wxMenuItem *result = 0 ;
38833 void *argp1 = 0 ;
38834 int res1 = 0 ;
38835 int res2 = 0 ;
38836 PyObject * obj0 = 0 ;
38837 PyObject * obj1 = 0 ;
38838 char * kwnames[] = {
38839 (char *) "self",(char *) "item", NULL
38840 };
38841
38842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38844 if (!SWIG_IsOK(res1)) {
38845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38846 }
38847 arg1 = reinterpret_cast< wxMenu * >(argp1);
38848 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38849 if (!SWIG_IsOK(res2)) {
38850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38851 }
38852 {
38853 PyThreadState* __tstate = wxPyBeginAllowThreads();
38854 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38855 wxPyEndAllowThreads(__tstate);
38856 if (PyErr_Occurred()) SWIG_fail;
38857 }
38858 {
38859 resultobj = wxPyMake_wxObject(result, (bool)0);
38860 }
38861 return resultobj;
38862 fail:
38863 return NULL;
38864 }
38865
38866
38867 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38868 PyObject *resultobj = 0;
38869 wxMenu *arg1 = (wxMenu *) 0 ;
38870 void *argp1 = 0 ;
38871 int res1 = 0 ;
38872 PyObject *swig_obj[1] ;
38873
38874 if (!args) SWIG_fail;
38875 swig_obj[0] = args;
38876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38877 if (!SWIG_IsOK(res1)) {
38878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38879 }
38880 arg1 = reinterpret_cast< wxMenu * >(argp1);
38881 {
38882 PyThreadState* __tstate = wxPyBeginAllowThreads();
38883 (arg1)->Break();
38884 wxPyEndAllowThreads(__tstate);
38885 if (PyErr_Occurred()) SWIG_fail;
38886 }
38887 resultobj = SWIG_Py_Void();
38888 return resultobj;
38889 fail:
38890 return NULL;
38891 }
38892
38893
38894 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38895 PyObject *resultobj = 0;
38896 wxMenu *arg1 = (wxMenu *) 0 ;
38897 size_t arg2 ;
38898 int arg3 ;
38899 wxString *arg4 = 0 ;
38900 wxString const &arg5_defvalue = wxPyEmptyString ;
38901 wxString *arg5 = (wxString *) &arg5_defvalue ;
38902 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38903 wxMenuItem *result = 0 ;
38904 void *argp1 = 0 ;
38905 int res1 = 0 ;
38906 size_t val2 ;
38907 int ecode2 = 0 ;
38908 int val3 ;
38909 int ecode3 = 0 ;
38910 bool temp4 = false ;
38911 bool temp5 = false ;
38912 int val6 ;
38913 int ecode6 = 0 ;
38914 PyObject * obj0 = 0 ;
38915 PyObject * obj1 = 0 ;
38916 PyObject * obj2 = 0 ;
38917 PyObject * obj3 = 0 ;
38918 PyObject * obj4 = 0 ;
38919 PyObject * obj5 = 0 ;
38920 char * kwnames[] = {
38921 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38922 };
38923
38924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38926 if (!SWIG_IsOK(res1)) {
38927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38928 }
38929 arg1 = reinterpret_cast< wxMenu * >(argp1);
38930 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38931 if (!SWIG_IsOK(ecode2)) {
38932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38933 }
38934 arg2 = static_cast< size_t >(val2);
38935 ecode3 = SWIG_AsVal_int(obj2, &val3);
38936 if (!SWIG_IsOK(ecode3)) {
38937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38938 }
38939 arg3 = static_cast< int >(val3);
38940 {
38941 arg4 = wxString_in_helper(obj3);
38942 if (arg4 == NULL) SWIG_fail;
38943 temp4 = true;
38944 }
38945 if (obj4) {
38946 {
38947 arg5 = wxString_in_helper(obj4);
38948 if (arg5 == NULL) SWIG_fail;
38949 temp5 = true;
38950 }
38951 }
38952 if (obj5) {
38953 ecode6 = SWIG_AsVal_int(obj5, &val6);
38954 if (!SWIG_IsOK(ecode6)) {
38955 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38956 }
38957 arg6 = static_cast< wxItemKind >(val6);
38958 }
38959 {
38960 PyThreadState* __tstate = wxPyBeginAllowThreads();
38961 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38962 wxPyEndAllowThreads(__tstate);
38963 if (PyErr_Occurred()) SWIG_fail;
38964 }
38965 {
38966 resultobj = wxPyMake_wxObject(result, (bool)0);
38967 }
38968 {
38969 if (temp4)
38970 delete arg4;
38971 }
38972 {
38973 if (temp5)
38974 delete arg5;
38975 }
38976 return resultobj;
38977 fail:
38978 {
38979 if (temp4)
38980 delete arg4;
38981 }
38982 {
38983 if (temp5)
38984 delete arg5;
38985 }
38986 return NULL;
38987 }
38988
38989
38990 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38991 PyObject *resultobj = 0;
38992 wxMenu *arg1 = (wxMenu *) 0 ;
38993 size_t arg2 ;
38994 wxMenuItem *result = 0 ;
38995 void *argp1 = 0 ;
38996 int res1 = 0 ;
38997 size_t val2 ;
38998 int ecode2 = 0 ;
38999 PyObject * obj0 = 0 ;
39000 PyObject * obj1 = 0 ;
39001 char * kwnames[] = {
39002 (char *) "self",(char *) "pos", NULL
39003 };
39004
39005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39007 if (!SWIG_IsOK(res1)) {
39008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39009 }
39010 arg1 = reinterpret_cast< wxMenu * >(argp1);
39011 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39012 if (!SWIG_IsOK(ecode2)) {
39013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39014 }
39015 arg2 = static_cast< size_t >(val2);
39016 {
39017 PyThreadState* __tstate = wxPyBeginAllowThreads();
39018 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39019 wxPyEndAllowThreads(__tstate);
39020 if (PyErr_Occurred()) SWIG_fail;
39021 }
39022 {
39023 resultobj = wxPyMake_wxObject(result, (bool)0);
39024 }
39025 return resultobj;
39026 fail:
39027 return NULL;
39028 }
39029
39030
39031 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39032 PyObject *resultobj = 0;
39033 wxMenu *arg1 = (wxMenu *) 0 ;
39034 size_t arg2 ;
39035 int arg3 ;
39036 wxString *arg4 = 0 ;
39037 wxString const &arg5_defvalue = wxPyEmptyString ;
39038 wxString *arg5 = (wxString *) &arg5_defvalue ;
39039 wxMenuItem *result = 0 ;
39040 void *argp1 = 0 ;
39041 int res1 = 0 ;
39042 size_t val2 ;
39043 int ecode2 = 0 ;
39044 int val3 ;
39045 int ecode3 = 0 ;
39046 bool temp4 = false ;
39047 bool temp5 = false ;
39048 PyObject * obj0 = 0 ;
39049 PyObject * obj1 = 0 ;
39050 PyObject * obj2 = 0 ;
39051 PyObject * obj3 = 0 ;
39052 PyObject * obj4 = 0 ;
39053 char * kwnames[] = {
39054 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39055 };
39056
39057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39059 if (!SWIG_IsOK(res1)) {
39060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39061 }
39062 arg1 = reinterpret_cast< wxMenu * >(argp1);
39063 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39064 if (!SWIG_IsOK(ecode2)) {
39065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39066 }
39067 arg2 = static_cast< size_t >(val2);
39068 ecode3 = SWIG_AsVal_int(obj2, &val3);
39069 if (!SWIG_IsOK(ecode3)) {
39070 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39071 }
39072 arg3 = static_cast< int >(val3);
39073 {
39074 arg4 = wxString_in_helper(obj3);
39075 if (arg4 == NULL) SWIG_fail;
39076 temp4 = true;
39077 }
39078 if (obj4) {
39079 {
39080 arg5 = wxString_in_helper(obj4);
39081 if (arg5 == NULL) SWIG_fail;
39082 temp5 = true;
39083 }
39084 }
39085 {
39086 PyThreadState* __tstate = wxPyBeginAllowThreads();
39087 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39088 wxPyEndAllowThreads(__tstate);
39089 if (PyErr_Occurred()) SWIG_fail;
39090 }
39091 {
39092 resultobj = wxPyMake_wxObject(result, (bool)0);
39093 }
39094 {
39095 if (temp4)
39096 delete arg4;
39097 }
39098 {
39099 if (temp5)
39100 delete arg5;
39101 }
39102 return resultobj;
39103 fail:
39104 {
39105 if (temp4)
39106 delete arg4;
39107 }
39108 {
39109 if (temp5)
39110 delete arg5;
39111 }
39112 return NULL;
39113 }
39114
39115
39116 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39117 PyObject *resultobj = 0;
39118 wxMenu *arg1 = (wxMenu *) 0 ;
39119 size_t arg2 ;
39120 int arg3 ;
39121 wxString *arg4 = 0 ;
39122 wxString const &arg5_defvalue = wxPyEmptyString ;
39123 wxString *arg5 = (wxString *) &arg5_defvalue ;
39124 wxMenuItem *result = 0 ;
39125 void *argp1 = 0 ;
39126 int res1 = 0 ;
39127 size_t val2 ;
39128 int ecode2 = 0 ;
39129 int val3 ;
39130 int ecode3 = 0 ;
39131 bool temp4 = false ;
39132 bool temp5 = false ;
39133 PyObject * obj0 = 0 ;
39134 PyObject * obj1 = 0 ;
39135 PyObject * obj2 = 0 ;
39136 PyObject * obj3 = 0 ;
39137 PyObject * obj4 = 0 ;
39138 char * kwnames[] = {
39139 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39140 };
39141
39142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39144 if (!SWIG_IsOK(res1)) {
39145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39146 }
39147 arg1 = reinterpret_cast< wxMenu * >(argp1);
39148 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39149 if (!SWIG_IsOK(ecode2)) {
39150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39151 }
39152 arg2 = static_cast< size_t >(val2);
39153 ecode3 = SWIG_AsVal_int(obj2, &val3);
39154 if (!SWIG_IsOK(ecode3)) {
39155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39156 }
39157 arg3 = static_cast< int >(val3);
39158 {
39159 arg4 = wxString_in_helper(obj3);
39160 if (arg4 == NULL) SWIG_fail;
39161 temp4 = true;
39162 }
39163 if (obj4) {
39164 {
39165 arg5 = wxString_in_helper(obj4);
39166 if (arg5 == NULL) SWIG_fail;
39167 temp5 = true;
39168 }
39169 }
39170 {
39171 PyThreadState* __tstate = wxPyBeginAllowThreads();
39172 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39173 wxPyEndAllowThreads(__tstate);
39174 if (PyErr_Occurred()) SWIG_fail;
39175 }
39176 {
39177 resultobj = wxPyMake_wxObject(result, (bool)0);
39178 }
39179 {
39180 if (temp4)
39181 delete arg4;
39182 }
39183 {
39184 if (temp5)
39185 delete arg5;
39186 }
39187 return resultobj;
39188 fail:
39189 {
39190 if (temp4)
39191 delete arg4;
39192 }
39193 {
39194 if (temp5)
39195 delete arg5;
39196 }
39197 return NULL;
39198 }
39199
39200
39201 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39202 PyObject *resultobj = 0;
39203 wxMenu *arg1 = (wxMenu *) 0 ;
39204 size_t arg2 ;
39205 int arg3 ;
39206 wxString *arg4 = 0 ;
39207 wxMenu *arg5 = (wxMenu *) 0 ;
39208 wxString const &arg6_defvalue = wxPyEmptyString ;
39209 wxString *arg6 = (wxString *) &arg6_defvalue ;
39210 wxMenuItem *result = 0 ;
39211 void *argp1 = 0 ;
39212 int res1 = 0 ;
39213 size_t val2 ;
39214 int ecode2 = 0 ;
39215 int val3 ;
39216 int ecode3 = 0 ;
39217 bool temp4 = false ;
39218 void *argp5 = 0 ;
39219 int res5 = 0 ;
39220 bool temp6 = false ;
39221 PyObject * obj0 = 0 ;
39222 PyObject * obj1 = 0 ;
39223 PyObject * obj2 = 0 ;
39224 PyObject * obj3 = 0 ;
39225 PyObject * obj4 = 0 ;
39226 PyObject * obj5 = 0 ;
39227 char * kwnames[] = {
39228 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39229 };
39230
39231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39233 if (!SWIG_IsOK(res1)) {
39234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39235 }
39236 arg1 = reinterpret_cast< wxMenu * >(argp1);
39237 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39238 if (!SWIG_IsOK(ecode2)) {
39239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39240 }
39241 arg2 = static_cast< size_t >(val2);
39242 ecode3 = SWIG_AsVal_int(obj2, &val3);
39243 if (!SWIG_IsOK(ecode3)) {
39244 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39245 }
39246 arg3 = static_cast< int >(val3);
39247 {
39248 arg4 = wxString_in_helper(obj3);
39249 if (arg4 == NULL) SWIG_fail;
39250 temp4 = true;
39251 }
39252 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39253 if (!SWIG_IsOK(res5)) {
39254 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39255 }
39256 arg5 = reinterpret_cast< wxMenu * >(argp5);
39257 if (obj5) {
39258 {
39259 arg6 = wxString_in_helper(obj5);
39260 if (arg6 == NULL) SWIG_fail;
39261 temp6 = true;
39262 }
39263 }
39264 {
39265 PyThreadState* __tstate = wxPyBeginAllowThreads();
39266 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39267 wxPyEndAllowThreads(__tstate);
39268 if (PyErr_Occurred()) SWIG_fail;
39269 }
39270 {
39271 resultobj = wxPyMake_wxObject(result, (bool)0);
39272 }
39273 {
39274 if (temp4)
39275 delete arg4;
39276 }
39277 {
39278 if (temp6)
39279 delete arg6;
39280 }
39281 return resultobj;
39282 fail:
39283 {
39284 if (temp4)
39285 delete arg4;
39286 }
39287 {
39288 if (temp6)
39289 delete arg6;
39290 }
39291 return NULL;
39292 }
39293
39294
39295 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39296 PyObject *resultobj = 0;
39297 wxMenu *arg1 = (wxMenu *) 0 ;
39298 int arg2 ;
39299 wxString *arg3 = 0 ;
39300 wxString const &arg4_defvalue = wxPyEmptyString ;
39301 wxString *arg4 = (wxString *) &arg4_defvalue ;
39302 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39303 wxMenuItem *result = 0 ;
39304 void *argp1 = 0 ;
39305 int res1 = 0 ;
39306 int val2 ;
39307 int ecode2 = 0 ;
39308 bool temp3 = false ;
39309 bool temp4 = false ;
39310 int val5 ;
39311 int ecode5 = 0 ;
39312 PyObject * obj0 = 0 ;
39313 PyObject * obj1 = 0 ;
39314 PyObject * obj2 = 0 ;
39315 PyObject * obj3 = 0 ;
39316 PyObject * obj4 = 0 ;
39317 char * kwnames[] = {
39318 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39319 };
39320
39321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39323 if (!SWIG_IsOK(res1)) {
39324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39325 }
39326 arg1 = reinterpret_cast< wxMenu * >(argp1);
39327 ecode2 = SWIG_AsVal_int(obj1, &val2);
39328 if (!SWIG_IsOK(ecode2)) {
39329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39330 }
39331 arg2 = static_cast< int >(val2);
39332 {
39333 arg3 = wxString_in_helper(obj2);
39334 if (arg3 == NULL) SWIG_fail;
39335 temp3 = true;
39336 }
39337 if (obj3) {
39338 {
39339 arg4 = wxString_in_helper(obj3);
39340 if (arg4 == NULL) SWIG_fail;
39341 temp4 = true;
39342 }
39343 }
39344 if (obj4) {
39345 ecode5 = SWIG_AsVal_int(obj4, &val5);
39346 if (!SWIG_IsOK(ecode5)) {
39347 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39348 }
39349 arg5 = static_cast< wxItemKind >(val5);
39350 }
39351 {
39352 PyThreadState* __tstate = wxPyBeginAllowThreads();
39353 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39354 wxPyEndAllowThreads(__tstate);
39355 if (PyErr_Occurred()) SWIG_fail;
39356 }
39357 {
39358 resultobj = wxPyMake_wxObject(result, (bool)0);
39359 }
39360 {
39361 if (temp3)
39362 delete arg3;
39363 }
39364 {
39365 if (temp4)
39366 delete arg4;
39367 }
39368 return resultobj;
39369 fail:
39370 {
39371 if (temp3)
39372 delete arg3;
39373 }
39374 {
39375 if (temp4)
39376 delete arg4;
39377 }
39378 return NULL;
39379 }
39380
39381
39382 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39383 PyObject *resultobj = 0;
39384 wxMenu *arg1 = (wxMenu *) 0 ;
39385 wxMenuItem *result = 0 ;
39386 void *argp1 = 0 ;
39387 int res1 = 0 ;
39388 PyObject *swig_obj[1] ;
39389
39390 if (!args) SWIG_fail;
39391 swig_obj[0] = args;
39392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39393 if (!SWIG_IsOK(res1)) {
39394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39395 }
39396 arg1 = reinterpret_cast< wxMenu * >(argp1);
39397 {
39398 PyThreadState* __tstate = wxPyBeginAllowThreads();
39399 result = (wxMenuItem *)(arg1)->PrependSeparator();
39400 wxPyEndAllowThreads(__tstate);
39401 if (PyErr_Occurred()) SWIG_fail;
39402 }
39403 {
39404 resultobj = wxPyMake_wxObject(result, (bool)0);
39405 }
39406 return resultobj;
39407 fail:
39408 return NULL;
39409 }
39410
39411
39412 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39413 PyObject *resultobj = 0;
39414 wxMenu *arg1 = (wxMenu *) 0 ;
39415 int arg2 ;
39416 wxString *arg3 = 0 ;
39417 wxString const &arg4_defvalue = wxPyEmptyString ;
39418 wxString *arg4 = (wxString *) &arg4_defvalue ;
39419 wxMenuItem *result = 0 ;
39420 void *argp1 = 0 ;
39421 int res1 = 0 ;
39422 int val2 ;
39423 int ecode2 = 0 ;
39424 bool temp3 = false ;
39425 bool temp4 = false ;
39426 PyObject * obj0 = 0 ;
39427 PyObject * obj1 = 0 ;
39428 PyObject * obj2 = 0 ;
39429 PyObject * obj3 = 0 ;
39430 char * kwnames[] = {
39431 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39432 };
39433
39434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39436 if (!SWIG_IsOK(res1)) {
39437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39438 }
39439 arg1 = reinterpret_cast< wxMenu * >(argp1);
39440 ecode2 = SWIG_AsVal_int(obj1, &val2);
39441 if (!SWIG_IsOK(ecode2)) {
39442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39443 }
39444 arg2 = static_cast< int >(val2);
39445 {
39446 arg3 = wxString_in_helper(obj2);
39447 if (arg3 == NULL) SWIG_fail;
39448 temp3 = true;
39449 }
39450 if (obj3) {
39451 {
39452 arg4 = wxString_in_helper(obj3);
39453 if (arg4 == NULL) SWIG_fail;
39454 temp4 = true;
39455 }
39456 }
39457 {
39458 PyThreadState* __tstate = wxPyBeginAllowThreads();
39459 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39460 wxPyEndAllowThreads(__tstate);
39461 if (PyErr_Occurred()) SWIG_fail;
39462 }
39463 {
39464 resultobj = wxPyMake_wxObject(result, (bool)0);
39465 }
39466 {
39467 if (temp3)
39468 delete arg3;
39469 }
39470 {
39471 if (temp4)
39472 delete arg4;
39473 }
39474 return resultobj;
39475 fail:
39476 {
39477 if (temp3)
39478 delete arg3;
39479 }
39480 {
39481 if (temp4)
39482 delete arg4;
39483 }
39484 return NULL;
39485 }
39486
39487
39488 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39489 PyObject *resultobj = 0;
39490 wxMenu *arg1 = (wxMenu *) 0 ;
39491 int arg2 ;
39492 wxString *arg3 = 0 ;
39493 wxString const &arg4_defvalue = wxPyEmptyString ;
39494 wxString *arg4 = (wxString *) &arg4_defvalue ;
39495 wxMenuItem *result = 0 ;
39496 void *argp1 = 0 ;
39497 int res1 = 0 ;
39498 int val2 ;
39499 int ecode2 = 0 ;
39500 bool temp3 = false ;
39501 bool temp4 = false ;
39502 PyObject * obj0 = 0 ;
39503 PyObject * obj1 = 0 ;
39504 PyObject * obj2 = 0 ;
39505 PyObject * obj3 = 0 ;
39506 char * kwnames[] = {
39507 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39508 };
39509
39510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39514 }
39515 arg1 = reinterpret_cast< wxMenu * >(argp1);
39516 ecode2 = SWIG_AsVal_int(obj1, &val2);
39517 if (!SWIG_IsOK(ecode2)) {
39518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39519 }
39520 arg2 = static_cast< int >(val2);
39521 {
39522 arg3 = wxString_in_helper(obj2);
39523 if (arg3 == NULL) SWIG_fail;
39524 temp3 = true;
39525 }
39526 if (obj3) {
39527 {
39528 arg4 = wxString_in_helper(obj3);
39529 if (arg4 == NULL) SWIG_fail;
39530 temp4 = true;
39531 }
39532 }
39533 {
39534 PyThreadState* __tstate = wxPyBeginAllowThreads();
39535 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39536 wxPyEndAllowThreads(__tstate);
39537 if (PyErr_Occurred()) SWIG_fail;
39538 }
39539 {
39540 resultobj = wxPyMake_wxObject(result, (bool)0);
39541 }
39542 {
39543 if (temp3)
39544 delete arg3;
39545 }
39546 {
39547 if (temp4)
39548 delete arg4;
39549 }
39550 return resultobj;
39551 fail:
39552 {
39553 if (temp3)
39554 delete arg3;
39555 }
39556 {
39557 if (temp4)
39558 delete arg4;
39559 }
39560 return NULL;
39561 }
39562
39563
39564 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39565 PyObject *resultobj = 0;
39566 wxMenu *arg1 = (wxMenu *) 0 ;
39567 int arg2 ;
39568 wxString *arg3 = 0 ;
39569 wxMenu *arg4 = (wxMenu *) 0 ;
39570 wxString const &arg5_defvalue = wxPyEmptyString ;
39571 wxString *arg5 = (wxString *) &arg5_defvalue ;
39572 wxMenuItem *result = 0 ;
39573 void *argp1 = 0 ;
39574 int res1 = 0 ;
39575 int val2 ;
39576 int ecode2 = 0 ;
39577 bool temp3 = false ;
39578 void *argp4 = 0 ;
39579 int res4 = 0 ;
39580 bool temp5 = false ;
39581 PyObject * obj0 = 0 ;
39582 PyObject * obj1 = 0 ;
39583 PyObject * obj2 = 0 ;
39584 PyObject * obj3 = 0 ;
39585 PyObject * obj4 = 0 ;
39586 char * kwnames[] = {
39587 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39588 };
39589
39590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39592 if (!SWIG_IsOK(res1)) {
39593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39594 }
39595 arg1 = reinterpret_cast< wxMenu * >(argp1);
39596 ecode2 = SWIG_AsVal_int(obj1, &val2);
39597 if (!SWIG_IsOK(ecode2)) {
39598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39599 }
39600 arg2 = static_cast< int >(val2);
39601 {
39602 arg3 = wxString_in_helper(obj2);
39603 if (arg3 == NULL) SWIG_fail;
39604 temp3 = true;
39605 }
39606 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39607 if (!SWIG_IsOK(res4)) {
39608 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39609 }
39610 arg4 = reinterpret_cast< wxMenu * >(argp4);
39611 if (obj4) {
39612 {
39613 arg5 = wxString_in_helper(obj4);
39614 if (arg5 == NULL) SWIG_fail;
39615 temp5 = true;
39616 }
39617 }
39618 {
39619 PyThreadState* __tstate = wxPyBeginAllowThreads();
39620 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39621 wxPyEndAllowThreads(__tstate);
39622 if (PyErr_Occurred()) SWIG_fail;
39623 }
39624 {
39625 resultobj = wxPyMake_wxObject(result, (bool)0);
39626 }
39627 {
39628 if (temp3)
39629 delete arg3;
39630 }
39631 {
39632 if (temp5)
39633 delete arg5;
39634 }
39635 return resultobj;
39636 fail:
39637 {
39638 if (temp3)
39639 delete arg3;
39640 }
39641 {
39642 if (temp5)
39643 delete arg5;
39644 }
39645 return NULL;
39646 }
39647
39648
39649 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39650 PyObject *resultobj = 0;
39651 wxMenu *arg1 = (wxMenu *) 0 ;
39652 int arg2 ;
39653 wxMenuItem *result = 0 ;
39654 void *argp1 = 0 ;
39655 int res1 = 0 ;
39656 int val2 ;
39657 int ecode2 = 0 ;
39658 PyObject * obj0 = 0 ;
39659 PyObject * obj1 = 0 ;
39660 char * kwnames[] = {
39661 (char *) "self",(char *) "id", NULL
39662 };
39663
39664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39666 if (!SWIG_IsOK(res1)) {
39667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39668 }
39669 arg1 = reinterpret_cast< wxMenu * >(argp1);
39670 ecode2 = SWIG_AsVal_int(obj1, &val2);
39671 if (!SWIG_IsOK(ecode2)) {
39672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39673 }
39674 arg2 = static_cast< int >(val2);
39675 {
39676 PyThreadState* __tstate = wxPyBeginAllowThreads();
39677 result = (wxMenuItem *)(arg1)->Remove(arg2);
39678 wxPyEndAllowThreads(__tstate);
39679 if (PyErr_Occurred()) SWIG_fail;
39680 }
39681 {
39682 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39683 }
39684 return resultobj;
39685 fail:
39686 return NULL;
39687 }
39688
39689
39690 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39691 PyObject *resultobj = 0;
39692 wxMenu *arg1 = (wxMenu *) 0 ;
39693 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39694 wxMenuItem *result = 0 ;
39695 void *argp1 = 0 ;
39696 int res1 = 0 ;
39697 void *argp2 = 0 ;
39698 int res2 = 0 ;
39699 PyObject * obj0 = 0 ;
39700 PyObject * obj1 = 0 ;
39701 char * kwnames[] = {
39702 (char *) "self",(char *) "item", NULL
39703 };
39704
39705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39707 if (!SWIG_IsOK(res1)) {
39708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39709 }
39710 arg1 = reinterpret_cast< wxMenu * >(argp1);
39711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39712 if (!SWIG_IsOK(res2)) {
39713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39714 }
39715 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39716 {
39717 PyThreadState* __tstate = wxPyBeginAllowThreads();
39718 result = (wxMenuItem *)(arg1)->Remove(arg2);
39719 wxPyEndAllowThreads(__tstate);
39720 if (PyErr_Occurred()) SWIG_fail;
39721 }
39722 {
39723 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39724 }
39725 return resultobj;
39726 fail:
39727 return NULL;
39728 }
39729
39730
39731 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39732 PyObject *resultobj = 0;
39733 wxMenu *arg1 = (wxMenu *) 0 ;
39734 int arg2 ;
39735 bool result;
39736 void *argp1 = 0 ;
39737 int res1 = 0 ;
39738 int val2 ;
39739 int ecode2 = 0 ;
39740 PyObject * obj0 = 0 ;
39741 PyObject * obj1 = 0 ;
39742 char * kwnames[] = {
39743 (char *) "self",(char *) "id", NULL
39744 };
39745
39746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39748 if (!SWIG_IsOK(res1)) {
39749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39750 }
39751 arg1 = reinterpret_cast< wxMenu * >(argp1);
39752 ecode2 = SWIG_AsVal_int(obj1, &val2);
39753 if (!SWIG_IsOK(ecode2)) {
39754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39755 }
39756 arg2 = static_cast< int >(val2);
39757 {
39758 PyThreadState* __tstate = wxPyBeginAllowThreads();
39759 result = (bool)(arg1)->Delete(arg2);
39760 wxPyEndAllowThreads(__tstate);
39761 if (PyErr_Occurred()) SWIG_fail;
39762 }
39763 {
39764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39765 }
39766 return resultobj;
39767 fail:
39768 return NULL;
39769 }
39770
39771
39772 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39773 PyObject *resultobj = 0;
39774 wxMenu *arg1 = (wxMenu *) 0 ;
39775 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39776 bool result;
39777 void *argp1 = 0 ;
39778 int res1 = 0 ;
39779 void *argp2 = 0 ;
39780 int res2 = 0 ;
39781 PyObject * obj0 = 0 ;
39782 PyObject * obj1 = 0 ;
39783 char * kwnames[] = {
39784 (char *) "self",(char *) "item", NULL
39785 };
39786
39787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39789 if (!SWIG_IsOK(res1)) {
39790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39791 }
39792 arg1 = reinterpret_cast< wxMenu * >(argp1);
39793 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39794 if (!SWIG_IsOK(res2)) {
39795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39796 }
39797 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39798 {
39799 PyThreadState* __tstate = wxPyBeginAllowThreads();
39800 result = (bool)(arg1)->Delete(arg2);
39801 wxPyEndAllowThreads(__tstate);
39802 if (PyErr_Occurred()) SWIG_fail;
39803 }
39804 {
39805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39806 }
39807 return resultobj;
39808 fail:
39809 return NULL;
39810 }
39811
39812
39813 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39814 PyObject *resultobj = 0;
39815 wxMenu *arg1 = (wxMenu *) 0 ;
39816 void *argp1 = 0 ;
39817 int res1 = 0 ;
39818 PyObject *swig_obj[1] ;
39819
39820 if (!args) SWIG_fail;
39821 swig_obj[0] = args;
39822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39823 if (!SWIG_IsOK(res1)) {
39824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39825 }
39826 arg1 = reinterpret_cast< wxMenu * >(argp1);
39827 {
39828 PyThreadState* __tstate = wxPyBeginAllowThreads();
39829 wxMenu_Destroy(arg1);
39830 wxPyEndAllowThreads(__tstate);
39831 if (PyErr_Occurred()) SWIG_fail;
39832 }
39833 resultobj = SWIG_Py_Void();
39834 return resultobj;
39835 fail:
39836 return NULL;
39837 }
39838
39839
39840 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39841 PyObject *resultobj = 0;
39842 wxMenu *arg1 = (wxMenu *) 0 ;
39843 int arg2 ;
39844 bool result;
39845 void *argp1 = 0 ;
39846 int res1 = 0 ;
39847 int val2 ;
39848 int ecode2 = 0 ;
39849 PyObject * obj0 = 0 ;
39850 PyObject * obj1 = 0 ;
39851 char * kwnames[] = {
39852 (char *) "self",(char *) "id", NULL
39853 };
39854
39855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39857 if (!SWIG_IsOK(res1)) {
39858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39859 }
39860 arg1 = reinterpret_cast< wxMenu * >(argp1);
39861 ecode2 = SWIG_AsVal_int(obj1, &val2);
39862 if (!SWIG_IsOK(ecode2)) {
39863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39864 }
39865 arg2 = static_cast< int >(val2);
39866 {
39867 PyThreadState* __tstate = wxPyBeginAllowThreads();
39868 result = (bool)(arg1)->Destroy(arg2);
39869 wxPyEndAllowThreads(__tstate);
39870 if (PyErr_Occurred()) SWIG_fail;
39871 }
39872 {
39873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39874 }
39875 return resultobj;
39876 fail:
39877 return NULL;
39878 }
39879
39880
39881 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39882 PyObject *resultobj = 0;
39883 wxMenu *arg1 = (wxMenu *) 0 ;
39884 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39885 bool result;
39886 void *argp1 = 0 ;
39887 int res1 = 0 ;
39888 void *argp2 = 0 ;
39889 int res2 = 0 ;
39890 PyObject * obj0 = 0 ;
39891 PyObject * obj1 = 0 ;
39892 char * kwnames[] = {
39893 (char *) "self",(char *) "item", NULL
39894 };
39895
39896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39898 if (!SWIG_IsOK(res1)) {
39899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39900 }
39901 arg1 = reinterpret_cast< wxMenu * >(argp1);
39902 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39903 if (!SWIG_IsOK(res2)) {
39904 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39905 }
39906 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39907 {
39908 PyThreadState* __tstate = wxPyBeginAllowThreads();
39909 result = (bool)(arg1)->Destroy(arg2);
39910 wxPyEndAllowThreads(__tstate);
39911 if (PyErr_Occurred()) SWIG_fail;
39912 }
39913 {
39914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39915 }
39916 return resultobj;
39917 fail:
39918 return NULL;
39919 }
39920
39921
39922 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39923 PyObject *resultobj = 0;
39924 wxMenu *arg1 = (wxMenu *) 0 ;
39925 size_t result;
39926 void *argp1 = 0 ;
39927 int res1 = 0 ;
39928 PyObject *swig_obj[1] ;
39929
39930 if (!args) SWIG_fail;
39931 swig_obj[0] = args;
39932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39933 if (!SWIG_IsOK(res1)) {
39934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39935 }
39936 arg1 = reinterpret_cast< wxMenu * >(argp1);
39937 {
39938 PyThreadState* __tstate = wxPyBeginAllowThreads();
39939 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39940 wxPyEndAllowThreads(__tstate);
39941 if (PyErr_Occurred()) SWIG_fail;
39942 }
39943 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39944 return resultobj;
39945 fail:
39946 return NULL;
39947 }
39948
39949
39950 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39951 PyObject *resultobj = 0;
39952 wxMenu *arg1 = (wxMenu *) 0 ;
39953 PyObject *result = 0 ;
39954 void *argp1 = 0 ;
39955 int res1 = 0 ;
39956 PyObject *swig_obj[1] ;
39957
39958 if (!args) SWIG_fail;
39959 swig_obj[0] = args;
39960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39961 if (!SWIG_IsOK(res1)) {
39962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39963 }
39964 arg1 = reinterpret_cast< wxMenu * >(argp1);
39965 {
39966 PyThreadState* __tstate = wxPyBeginAllowThreads();
39967 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39968 wxPyEndAllowThreads(__tstate);
39969 if (PyErr_Occurred()) SWIG_fail;
39970 }
39971 resultobj = result;
39972 return resultobj;
39973 fail:
39974 return NULL;
39975 }
39976
39977
39978 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39979 PyObject *resultobj = 0;
39980 wxMenu *arg1 = (wxMenu *) 0 ;
39981 wxString *arg2 = 0 ;
39982 int result;
39983 void *argp1 = 0 ;
39984 int res1 = 0 ;
39985 bool temp2 = false ;
39986 PyObject * obj0 = 0 ;
39987 PyObject * obj1 = 0 ;
39988 char * kwnames[] = {
39989 (char *) "self",(char *) "item", NULL
39990 };
39991
39992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39994 if (!SWIG_IsOK(res1)) {
39995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39996 }
39997 arg1 = reinterpret_cast< wxMenu * >(argp1);
39998 {
39999 arg2 = wxString_in_helper(obj1);
40000 if (arg2 == NULL) SWIG_fail;
40001 temp2 = true;
40002 }
40003 {
40004 PyThreadState* __tstate = wxPyBeginAllowThreads();
40005 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40006 wxPyEndAllowThreads(__tstate);
40007 if (PyErr_Occurred()) SWIG_fail;
40008 }
40009 resultobj = SWIG_From_int(static_cast< int >(result));
40010 {
40011 if (temp2)
40012 delete arg2;
40013 }
40014 return resultobj;
40015 fail:
40016 {
40017 if (temp2)
40018 delete arg2;
40019 }
40020 return NULL;
40021 }
40022
40023
40024 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40025 PyObject *resultobj = 0;
40026 wxMenu *arg1 = (wxMenu *) 0 ;
40027 int arg2 ;
40028 wxMenuItem *result = 0 ;
40029 void *argp1 = 0 ;
40030 int res1 = 0 ;
40031 int val2 ;
40032 int ecode2 = 0 ;
40033 PyObject * obj0 = 0 ;
40034 PyObject * obj1 = 0 ;
40035 char * kwnames[] = {
40036 (char *) "self",(char *) "id", NULL
40037 };
40038
40039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40041 if (!SWIG_IsOK(res1)) {
40042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40043 }
40044 arg1 = reinterpret_cast< wxMenu * >(argp1);
40045 ecode2 = SWIG_AsVal_int(obj1, &val2);
40046 if (!SWIG_IsOK(ecode2)) {
40047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40048 }
40049 arg2 = static_cast< int >(val2);
40050 {
40051 PyThreadState* __tstate = wxPyBeginAllowThreads();
40052 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40053 wxPyEndAllowThreads(__tstate);
40054 if (PyErr_Occurred()) SWIG_fail;
40055 }
40056 {
40057 resultobj = wxPyMake_wxObject(result, (bool)0);
40058 }
40059 return resultobj;
40060 fail:
40061 return NULL;
40062 }
40063
40064
40065 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40066 PyObject *resultobj = 0;
40067 wxMenu *arg1 = (wxMenu *) 0 ;
40068 size_t arg2 ;
40069 wxMenuItem *result = 0 ;
40070 void *argp1 = 0 ;
40071 int res1 = 0 ;
40072 size_t val2 ;
40073 int ecode2 = 0 ;
40074 PyObject * obj0 = 0 ;
40075 PyObject * obj1 = 0 ;
40076 char * kwnames[] = {
40077 (char *) "self",(char *) "position", NULL
40078 };
40079
40080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40082 if (!SWIG_IsOK(res1)) {
40083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40084 }
40085 arg1 = reinterpret_cast< wxMenu * >(argp1);
40086 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40087 if (!SWIG_IsOK(ecode2)) {
40088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40089 }
40090 arg2 = static_cast< size_t >(val2);
40091 {
40092 PyThreadState* __tstate = wxPyBeginAllowThreads();
40093 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40094 wxPyEndAllowThreads(__tstate);
40095 if (PyErr_Occurred()) SWIG_fail;
40096 }
40097 {
40098 resultobj = wxPyMake_wxObject(result, (bool)0);
40099 }
40100 return resultobj;
40101 fail:
40102 return NULL;
40103 }
40104
40105
40106 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40107 PyObject *resultobj = 0;
40108 wxMenu *arg1 = (wxMenu *) 0 ;
40109 int arg2 ;
40110 bool arg3 ;
40111 void *argp1 = 0 ;
40112 int res1 = 0 ;
40113 int val2 ;
40114 int ecode2 = 0 ;
40115 bool val3 ;
40116 int ecode3 = 0 ;
40117 PyObject * obj0 = 0 ;
40118 PyObject * obj1 = 0 ;
40119 PyObject * obj2 = 0 ;
40120 char * kwnames[] = {
40121 (char *) "self",(char *) "id",(char *) "enable", NULL
40122 };
40123
40124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40126 if (!SWIG_IsOK(res1)) {
40127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40128 }
40129 arg1 = reinterpret_cast< wxMenu * >(argp1);
40130 ecode2 = SWIG_AsVal_int(obj1, &val2);
40131 if (!SWIG_IsOK(ecode2)) {
40132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40133 }
40134 arg2 = static_cast< int >(val2);
40135 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40136 if (!SWIG_IsOK(ecode3)) {
40137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40138 }
40139 arg3 = static_cast< bool >(val3);
40140 {
40141 PyThreadState* __tstate = wxPyBeginAllowThreads();
40142 (arg1)->Enable(arg2,arg3);
40143 wxPyEndAllowThreads(__tstate);
40144 if (PyErr_Occurred()) SWIG_fail;
40145 }
40146 resultobj = SWIG_Py_Void();
40147 return resultobj;
40148 fail:
40149 return NULL;
40150 }
40151
40152
40153 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40154 PyObject *resultobj = 0;
40155 wxMenu *arg1 = (wxMenu *) 0 ;
40156 int arg2 ;
40157 bool result;
40158 void *argp1 = 0 ;
40159 int res1 = 0 ;
40160 int val2 ;
40161 int ecode2 = 0 ;
40162 PyObject * obj0 = 0 ;
40163 PyObject * obj1 = 0 ;
40164 char * kwnames[] = {
40165 (char *) "self",(char *) "id", NULL
40166 };
40167
40168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40170 if (!SWIG_IsOK(res1)) {
40171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40172 }
40173 arg1 = reinterpret_cast< wxMenu * >(argp1);
40174 ecode2 = SWIG_AsVal_int(obj1, &val2);
40175 if (!SWIG_IsOK(ecode2)) {
40176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40177 }
40178 arg2 = static_cast< int >(val2);
40179 {
40180 PyThreadState* __tstate = wxPyBeginAllowThreads();
40181 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40182 wxPyEndAllowThreads(__tstate);
40183 if (PyErr_Occurred()) SWIG_fail;
40184 }
40185 {
40186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40187 }
40188 return resultobj;
40189 fail:
40190 return NULL;
40191 }
40192
40193
40194 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40195 PyObject *resultobj = 0;
40196 wxMenu *arg1 = (wxMenu *) 0 ;
40197 int arg2 ;
40198 bool arg3 ;
40199 void *argp1 = 0 ;
40200 int res1 = 0 ;
40201 int val2 ;
40202 int ecode2 = 0 ;
40203 bool val3 ;
40204 int ecode3 = 0 ;
40205 PyObject * obj0 = 0 ;
40206 PyObject * obj1 = 0 ;
40207 PyObject * obj2 = 0 ;
40208 char * kwnames[] = {
40209 (char *) "self",(char *) "id",(char *) "check", NULL
40210 };
40211
40212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40214 if (!SWIG_IsOK(res1)) {
40215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40216 }
40217 arg1 = reinterpret_cast< wxMenu * >(argp1);
40218 ecode2 = SWIG_AsVal_int(obj1, &val2);
40219 if (!SWIG_IsOK(ecode2)) {
40220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40221 }
40222 arg2 = static_cast< int >(val2);
40223 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40224 if (!SWIG_IsOK(ecode3)) {
40225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40226 }
40227 arg3 = static_cast< bool >(val3);
40228 {
40229 PyThreadState* __tstate = wxPyBeginAllowThreads();
40230 (arg1)->Check(arg2,arg3);
40231 wxPyEndAllowThreads(__tstate);
40232 if (PyErr_Occurred()) SWIG_fail;
40233 }
40234 resultobj = SWIG_Py_Void();
40235 return resultobj;
40236 fail:
40237 return NULL;
40238 }
40239
40240
40241 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40242 PyObject *resultobj = 0;
40243 wxMenu *arg1 = (wxMenu *) 0 ;
40244 int arg2 ;
40245 bool result;
40246 void *argp1 = 0 ;
40247 int res1 = 0 ;
40248 int val2 ;
40249 int ecode2 = 0 ;
40250 PyObject * obj0 = 0 ;
40251 PyObject * obj1 = 0 ;
40252 char * kwnames[] = {
40253 (char *) "self",(char *) "id", NULL
40254 };
40255
40256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40258 if (!SWIG_IsOK(res1)) {
40259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40260 }
40261 arg1 = reinterpret_cast< wxMenu * >(argp1);
40262 ecode2 = SWIG_AsVal_int(obj1, &val2);
40263 if (!SWIG_IsOK(ecode2)) {
40264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40265 }
40266 arg2 = static_cast< int >(val2);
40267 {
40268 PyThreadState* __tstate = wxPyBeginAllowThreads();
40269 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40270 wxPyEndAllowThreads(__tstate);
40271 if (PyErr_Occurred()) SWIG_fail;
40272 }
40273 {
40274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40275 }
40276 return resultobj;
40277 fail:
40278 return NULL;
40279 }
40280
40281
40282 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40283 PyObject *resultobj = 0;
40284 wxMenu *arg1 = (wxMenu *) 0 ;
40285 int arg2 ;
40286 wxString *arg3 = 0 ;
40287 void *argp1 = 0 ;
40288 int res1 = 0 ;
40289 int val2 ;
40290 int ecode2 = 0 ;
40291 bool temp3 = false ;
40292 PyObject * obj0 = 0 ;
40293 PyObject * obj1 = 0 ;
40294 PyObject * obj2 = 0 ;
40295 char * kwnames[] = {
40296 (char *) "self",(char *) "id",(char *) "label", NULL
40297 };
40298
40299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40301 if (!SWIG_IsOK(res1)) {
40302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40303 }
40304 arg1 = reinterpret_cast< wxMenu * >(argp1);
40305 ecode2 = SWIG_AsVal_int(obj1, &val2);
40306 if (!SWIG_IsOK(ecode2)) {
40307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40308 }
40309 arg2 = static_cast< int >(val2);
40310 {
40311 arg3 = wxString_in_helper(obj2);
40312 if (arg3 == NULL) SWIG_fail;
40313 temp3 = true;
40314 }
40315 {
40316 PyThreadState* __tstate = wxPyBeginAllowThreads();
40317 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40318 wxPyEndAllowThreads(__tstate);
40319 if (PyErr_Occurred()) SWIG_fail;
40320 }
40321 resultobj = SWIG_Py_Void();
40322 {
40323 if (temp3)
40324 delete arg3;
40325 }
40326 return resultobj;
40327 fail:
40328 {
40329 if (temp3)
40330 delete arg3;
40331 }
40332 return NULL;
40333 }
40334
40335
40336 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40337 PyObject *resultobj = 0;
40338 wxMenu *arg1 = (wxMenu *) 0 ;
40339 int arg2 ;
40340 wxString result;
40341 void *argp1 = 0 ;
40342 int res1 = 0 ;
40343 int val2 ;
40344 int ecode2 = 0 ;
40345 PyObject * obj0 = 0 ;
40346 PyObject * obj1 = 0 ;
40347 char * kwnames[] = {
40348 (char *) "self",(char *) "id", NULL
40349 };
40350
40351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40353 if (!SWIG_IsOK(res1)) {
40354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40355 }
40356 arg1 = reinterpret_cast< wxMenu * >(argp1);
40357 ecode2 = SWIG_AsVal_int(obj1, &val2);
40358 if (!SWIG_IsOK(ecode2)) {
40359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40360 }
40361 arg2 = static_cast< int >(val2);
40362 {
40363 PyThreadState* __tstate = wxPyBeginAllowThreads();
40364 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40365 wxPyEndAllowThreads(__tstate);
40366 if (PyErr_Occurred()) SWIG_fail;
40367 }
40368 {
40369 #if wxUSE_UNICODE
40370 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40371 #else
40372 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40373 #endif
40374 }
40375 return resultobj;
40376 fail:
40377 return NULL;
40378 }
40379
40380
40381 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40382 PyObject *resultobj = 0;
40383 wxMenu *arg1 = (wxMenu *) 0 ;
40384 int arg2 ;
40385 wxString *arg3 = 0 ;
40386 void *argp1 = 0 ;
40387 int res1 = 0 ;
40388 int val2 ;
40389 int ecode2 = 0 ;
40390 bool temp3 = false ;
40391 PyObject * obj0 = 0 ;
40392 PyObject * obj1 = 0 ;
40393 PyObject * obj2 = 0 ;
40394 char * kwnames[] = {
40395 (char *) "self",(char *) "id",(char *) "helpString", NULL
40396 };
40397
40398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40400 if (!SWIG_IsOK(res1)) {
40401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40402 }
40403 arg1 = reinterpret_cast< wxMenu * >(argp1);
40404 ecode2 = SWIG_AsVal_int(obj1, &val2);
40405 if (!SWIG_IsOK(ecode2)) {
40406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40407 }
40408 arg2 = static_cast< int >(val2);
40409 {
40410 arg3 = wxString_in_helper(obj2);
40411 if (arg3 == NULL) SWIG_fail;
40412 temp3 = true;
40413 }
40414 {
40415 PyThreadState* __tstate = wxPyBeginAllowThreads();
40416 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40417 wxPyEndAllowThreads(__tstate);
40418 if (PyErr_Occurred()) SWIG_fail;
40419 }
40420 resultobj = SWIG_Py_Void();
40421 {
40422 if (temp3)
40423 delete arg3;
40424 }
40425 return resultobj;
40426 fail:
40427 {
40428 if (temp3)
40429 delete arg3;
40430 }
40431 return NULL;
40432 }
40433
40434
40435 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40436 PyObject *resultobj = 0;
40437 wxMenu *arg1 = (wxMenu *) 0 ;
40438 int arg2 ;
40439 wxString result;
40440 void *argp1 = 0 ;
40441 int res1 = 0 ;
40442 int val2 ;
40443 int ecode2 = 0 ;
40444 PyObject * obj0 = 0 ;
40445 PyObject * obj1 = 0 ;
40446 char * kwnames[] = {
40447 (char *) "self",(char *) "id", NULL
40448 };
40449
40450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40452 if (!SWIG_IsOK(res1)) {
40453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40454 }
40455 arg1 = reinterpret_cast< wxMenu * >(argp1);
40456 ecode2 = SWIG_AsVal_int(obj1, &val2);
40457 if (!SWIG_IsOK(ecode2)) {
40458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40459 }
40460 arg2 = static_cast< int >(val2);
40461 {
40462 PyThreadState* __tstate = wxPyBeginAllowThreads();
40463 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40464 wxPyEndAllowThreads(__tstate);
40465 if (PyErr_Occurred()) SWIG_fail;
40466 }
40467 {
40468 #if wxUSE_UNICODE
40469 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40470 #else
40471 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40472 #endif
40473 }
40474 return resultobj;
40475 fail:
40476 return NULL;
40477 }
40478
40479
40480 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40481 PyObject *resultobj = 0;
40482 wxMenu *arg1 = (wxMenu *) 0 ;
40483 wxString *arg2 = 0 ;
40484 void *argp1 = 0 ;
40485 int res1 = 0 ;
40486 bool temp2 = false ;
40487 PyObject * obj0 = 0 ;
40488 PyObject * obj1 = 0 ;
40489 char * kwnames[] = {
40490 (char *) "self",(char *) "title", NULL
40491 };
40492
40493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40495 if (!SWIG_IsOK(res1)) {
40496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40497 }
40498 arg1 = reinterpret_cast< wxMenu * >(argp1);
40499 {
40500 arg2 = wxString_in_helper(obj1);
40501 if (arg2 == NULL) SWIG_fail;
40502 temp2 = true;
40503 }
40504 {
40505 PyThreadState* __tstate = wxPyBeginAllowThreads();
40506 (arg1)->SetTitle((wxString const &)*arg2);
40507 wxPyEndAllowThreads(__tstate);
40508 if (PyErr_Occurred()) SWIG_fail;
40509 }
40510 resultobj = SWIG_Py_Void();
40511 {
40512 if (temp2)
40513 delete arg2;
40514 }
40515 return resultobj;
40516 fail:
40517 {
40518 if (temp2)
40519 delete arg2;
40520 }
40521 return NULL;
40522 }
40523
40524
40525 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40526 PyObject *resultobj = 0;
40527 wxMenu *arg1 = (wxMenu *) 0 ;
40528 wxString result;
40529 void *argp1 = 0 ;
40530 int res1 = 0 ;
40531 PyObject *swig_obj[1] ;
40532
40533 if (!args) SWIG_fail;
40534 swig_obj[0] = args;
40535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40536 if (!SWIG_IsOK(res1)) {
40537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40538 }
40539 arg1 = reinterpret_cast< wxMenu * >(argp1);
40540 {
40541 PyThreadState* __tstate = wxPyBeginAllowThreads();
40542 result = ((wxMenu const *)arg1)->GetTitle();
40543 wxPyEndAllowThreads(__tstate);
40544 if (PyErr_Occurred()) SWIG_fail;
40545 }
40546 {
40547 #if wxUSE_UNICODE
40548 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40549 #else
40550 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40551 #endif
40552 }
40553 return resultobj;
40554 fail:
40555 return NULL;
40556 }
40557
40558
40559 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40560 PyObject *resultobj = 0;
40561 wxMenu *arg1 = (wxMenu *) 0 ;
40562 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40563 void *argp1 = 0 ;
40564 int res1 = 0 ;
40565 void *argp2 = 0 ;
40566 int res2 = 0 ;
40567 PyObject * obj0 = 0 ;
40568 PyObject * obj1 = 0 ;
40569 char * kwnames[] = {
40570 (char *) "self",(char *) "handler", NULL
40571 };
40572
40573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40575 if (!SWIG_IsOK(res1)) {
40576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40577 }
40578 arg1 = reinterpret_cast< wxMenu * >(argp1);
40579 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40580 if (!SWIG_IsOK(res2)) {
40581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40582 }
40583 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40584 {
40585 PyThreadState* __tstate = wxPyBeginAllowThreads();
40586 (arg1)->SetEventHandler(arg2);
40587 wxPyEndAllowThreads(__tstate);
40588 if (PyErr_Occurred()) SWIG_fail;
40589 }
40590 resultobj = SWIG_Py_Void();
40591 return resultobj;
40592 fail:
40593 return NULL;
40594 }
40595
40596
40597 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40598 PyObject *resultobj = 0;
40599 wxMenu *arg1 = (wxMenu *) 0 ;
40600 wxEvtHandler *result = 0 ;
40601 void *argp1 = 0 ;
40602 int res1 = 0 ;
40603 PyObject *swig_obj[1] ;
40604
40605 if (!args) SWIG_fail;
40606 swig_obj[0] = args;
40607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40608 if (!SWIG_IsOK(res1)) {
40609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40610 }
40611 arg1 = reinterpret_cast< wxMenu * >(argp1);
40612 {
40613 PyThreadState* __tstate = wxPyBeginAllowThreads();
40614 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40615 wxPyEndAllowThreads(__tstate);
40616 if (PyErr_Occurred()) SWIG_fail;
40617 }
40618 {
40619 resultobj = wxPyMake_wxObject(result, 0);
40620 }
40621 return resultobj;
40622 fail:
40623 return NULL;
40624 }
40625
40626
40627 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40628 PyObject *resultobj = 0;
40629 wxMenu *arg1 = (wxMenu *) 0 ;
40630 wxWindow *arg2 = (wxWindow *) 0 ;
40631 void *argp1 = 0 ;
40632 int res1 = 0 ;
40633 void *argp2 = 0 ;
40634 int res2 = 0 ;
40635 PyObject * obj0 = 0 ;
40636 PyObject * obj1 = 0 ;
40637 char * kwnames[] = {
40638 (char *) "self",(char *) "win", NULL
40639 };
40640
40641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40643 if (!SWIG_IsOK(res1)) {
40644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40645 }
40646 arg1 = reinterpret_cast< wxMenu * >(argp1);
40647 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40648 if (!SWIG_IsOK(res2)) {
40649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40650 }
40651 arg2 = reinterpret_cast< wxWindow * >(argp2);
40652 {
40653 PyThreadState* __tstate = wxPyBeginAllowThreads();
40654 (arg1)->SetInvokingWindow(arg2);
40655 wxPyEndAllowThreads(__tstate);
40656 if (PyErr_Occurred()) SWIG_fail;
40657 }
40658 resultobj = SWIG_Py_Void();
40659 return resultobj;
40660 fail:
40661 return NULL;
40662 }
40663
40664
40665 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40666 PyObject *resultobj = 0;
40667 wxMenu *arg1 = (wxMenu *) 0 ;
40668 wxWindow *result = 0 ;
40669 void *argp1 = 0 ;
40670 int res1 = 0 ;
40671 PyObject *swig_obj[1] ;
40672
40673 if (!args) SWIG_fail;
40674 swig_obj[0] = args;
40675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40676 if (!SWIG_IsOK(res1)) {
40677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40678 }
40679 arg1 = reinterpret_cast< wxMenu * >(argp1);
40680 {
40681 PyThreadState* __tstate = wxPyBeginAllowThreads();
40682 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40683 wxPyEndAllowThreads(__tstate);
40684 if (PyErr_Occurred()) SWIG_fail;
40685 }
40686 {
40687 resultobj = wxPyMake_wxObject(result, 0);
40688 }
40689 return resultobj;
40690 fail:
40691 return NULL;
40692 }
40693
40694
40695 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40696 PyObject *resultobj = 0;
40697 wxMenu *arg1 = (wxMenu *) 0 ;
40698 long result;
40699 void *argp1 = 0 ;
40700 int res1 = 0 ;
40701 PyObject *swig_obj[1] ;
40702
40703 if (!args) SWIG_fail;
40704 swig_obj[0] = args;
40705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40706 if (!SWIG_IsOK(res1)) {
40707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40708 }
40709 arg1 = reinterpret_cast< wxMenu * >(argp1);
40710 {
40711 PyThreadState* __tstate = wxPyBeginAllowThreads();
40712 result = (long)((wxMenu const *)arg1)->GetStyle();
40713 wxPyEndAllowThreads(__tstate);
40714 if (PyErr_Occurred()) SWIG_fail;
40715 }
40716 resultobj = SWIG_From_long(static_cast< long >(result));
40717 return resultobj;
40718 fail:
40719 return NULL;
40720 }
40721
40722
40723 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40724 PyObject *resultobj = 0;
40725 wxMenu *arg1 = (wxMenu *) 0 ;
40726 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40727 void *argp1 = 0 ;
40728 int res1 = 0 ;
40729 void *argp2 = 0 ;
40730 int res2 = 0 ;
40731 PyObject * obj0 = 0 ;
40732 PyObject * obj1 = 0 ;
40733 char * kwnames[] = {
40734 (char *) "self",(char *) "source", NULL
40735 };
40736
40737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40739 if (!SWIG_IsOK(res1)) {
40740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40741 }
40742 arg1 = reinterpret_cast< wxMenu * >(argp1);
40743 if (obj1) {
40744 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40745 if (!SWIG_IsOK(res2)) {
40746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40747 }
40748 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40749 }
40750 {
40751 PyThreadState* __tstate = wxPyBeginAllowThreads();
40752 (arg1)->UpdateUI(arg2);
40753 wxPyEndAllowThreads(__tstate);
40754 if (PyErr_Occurred()) SWIG_fail;
40755 }
40756 resultobj = SWIG_Py_Void();
40757 return resultobj;
40758 fail:
40759 return NULL;
40760 }
40761
40762
40763 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40764 PyObject *resultobj = 0;
40765 wxMenu *arg1 = (wxMenu *) 0 ;
40766 wxMenuBar *result = 0 ;
40767 void *argp1 = 0 ;
40768 int res1 = 0 ;
40769 PyObject *swig_obj[1] ;
40770
40771 if (!args) SWIG_fail;
40772 swig_obj[0] = args;
40773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40774 if (!SWIG_IsOK(res1)) {
40775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40776 }
40777 arg1 = reinterpret_cast< wxMenu * >(argp1);
40778 {
40779 PyThreadState* __tstate = wxPyBeginAllowThreads();
40780 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40781 wxPyEndAllowThreads(__tstate);
40782 if (PyErr_Occurred()) SWIG_fail;
40783 }
40784 {
40785 resultobj = wxPyMake_wxObject(result, (bool)0);
40786 }
40787 return resultobj;
40788 fail:
40789 return NULL;
40790 }
40791
40792
40793 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40794 PyObject *resultobj = 0;
40795 wxMenu *arg1 = (wxMenu *) 0 ;
40796 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40797 void *argp1 = 0 ;
40798 int res1 = 0 ;
40799 void *argp2 = 0 ;
40800 int res2 = 0 ;
40801 PyObject * obj0 = 0 ;
40802 PyObject * obj1 = 0 ;
40803 char * kwnames[] = {
40804 (char *) "self",(char *) "menubar", NULL
40805 };
40806
40807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40809 if (!SWIG_IsOK(res1)) {
40810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40811 }
40812 arg1 = reinterpret_cast< wxMenu * >(argp1);
40813 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40814 if (!SWIG_IsOK(res2)) {
40815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40816 }
40817 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40818 {
40819 PyThreadState* __tstate = wxPyBeginAllowThreads();
40820 (arg1)->Attach(arg2);
40821 wxPyEndAllowThreads(__tstate);
40822 if (PyErr_Occurred()) SWIG_fail;
40823 }
40824 resultobj = SWIG_Py_Void();
40825 return resultobj;
40826 fail:
40827 return NULL;
40828 }
40829
40830
40831 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40832 PyObject *resultobj = 0;
40833 wxMenu *arg1 = (wxMenu *) 0 ;
40834 void *argp1 = 0 ;
40835 int res1 = 0 ;
40836 PyObject *swig_obj[1] ;
40837
40838 if (!args) SWIG_fail;
40839 swig_obj[0] = args;
40840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40841 if (!SWIG_IsOK(res1)) {
40842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40843 }
40844 arg1 = reinterpret_cast< wxMenu * >(argp1);
40845 {
40846 PyThreadState* __tstate = wxPyBeginAllowThreads();
40847 (arg1)->Detach();
40848 wxPyEndAllowThreads(__tstate);
40849 if (PyErr_Occurred()) SWIG_fail;
40850 }
40851 resultobj = SWIG_Py_Void();
40852 return resultobj;
40853 fail:
40854 return NULL;
40855 }
40856
40857
40858 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40859 PyObject *resultobj = 0;
40860 wxMenu *arg1 = (wxMenu *) 0 ;
40861 bool result;
40862 void *argp1 = 0 ;
40863 int res1 = 0 ;
40864 PyObject *swig_obj[1] ;
40865
40866 if (!args) SWIG_fail;
40867 swig_obj[0] = args;
40868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40869 if (!SWIG_IsOK(res1)) {
40870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40871 }
40872 arg1 = reinterpret_cast< wxMenu * >(argp1);
40873 {
40874 PyThreadState* __tstate = wxPyBeginAllowThreads();
40875 result = (bool)((wxMenu const *)arg1)->IsAttached();
40876 wxPyEndAllowThreads(__tstate);
40877 if (PyErr_Occurred()) SWIG_fail;
40878 }
40879 {
40880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40881 }
40882 return resultobj;
40883 fail:
40884 return NULL;
40885 }
40886
40887
40888 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40889 PyObject *resultobj = 0;
40890 wxMenu *arg1 = (wxMenu *) 0 ;
40891 wxMenu *arg2 = (wxMenu *) 0 ;
40892 void *argp1 = 0 ;
40893 int res1 = 0 ;
40894 void *argp2 = 0 ;
40895 int res2 = 0 ;
40896 PyObject * obj0 = 0 ;
40897 PyObject * obj1 = 0 ;
40898 char * kwnames[] = {
40899 (char *) "self",(char *) "parent", NULL
40900 };
40901
40902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40904 if (!SWIG_IsOK(res1)) {
40905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40906 }
40907 arg1 = reinterpret_cast< wxMenu * >(argp1);
40908 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40909 if (!SWIG_IsOK(res2)) {
40910 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40911 }
40912 arg2 = reinterpret_cast< wxMenu * >(argp2);
40913 {
40914 PyThreadState* __tstate = wxPyBeginAllowThreads();
40915 (arg1)->SetParent(arg2);
40916 wxPyEndAllowThreads(__tstate);
40917 if (PyErr_Occurred()) SWIG_fail;
40918 }
40919 resultobj = SWIG_Py_Void();
40920 return resultobj;
40921 fail:
40922 return NULL;
40923 }
40924
40925
40926 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40927 PyObject *resultobj = 0;
40928 wxMenu *arg1 = (wxMenu *) 0 ;
40929 wxMenu *result = 0 ;
40930 void *argp1 = 0 ;
40931 int res1 = 0 ;
40932 PyObject *swig_obj[1] ;
40933
40934 if (!args) SWIG_fail;
40935 swig_obj[0] = args;
40936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40937 if (!SWIG_IsOK(res1)) {
40938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40939 }
40940 arg1 = reinterpret_cast< wxMenu * >(argp1);
40941 {
40942 PyThreadState* __tstate = wxPyBeginAllowThreads();
40943 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40944 wxPyEndAllowThreads(__tstate);
40945 if (PyErr_Occurred()) SWIG_fail;
40946 }
40947 {
40948 resultobj = wxPyMake_wxObject(result, 0);
40949 }
40950 return resultobj;
40951 fail:
40952 return NULL;
40953 }
40954
40955
40956 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40957 PyObject *obj;
40958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40959 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40960 return SWIG_Py_Void();
40961 }
40962
40963 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40964 return SWIG_Python_InitShadowInstance(args);
40965 }
40966
40967 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40968 PyObject *resultobj = 0;
40969 long arg1 = (long) 0 ;
40970 wxMenuBar *result = 0 ;
40971 long val1 ;
40972 int ecode1 = 0 ;
40973 PyObject * obj0 = 0 ;
40974 char * kwnames[] = {
40975 (char *) "style", NULL
40976 };
40977
40978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40979 if (obj0) {
40980 ecode1 = SWIG_AsVal_long(obj0, &val1);
40981 if (!SWIG_IsOK(ecode1)) {
40982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40983 }
40984 arg1 = static_cast< long >(val1);
40985 }
40986 {
40987 if (!wxPyCheckForApp()) SWIG_fail;
40988 PyThreadState* __tstate = wxPyBeginAllowThreads();
40989 result = (wxMenuBar *)new wxMenuBar(arg1);
40990 wxPyEndAllowThreads(__tstate);
40991 if (PyErr_Occurred()) SWIG_fail;
40992 }
40993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40994 return resultobj;
40995 fail:
40996 return NULL;
40997 }
40998
40999
41000 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41001 PyObject *resultobj = 0;
41002 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41003 wxMenu *arg2 = (wxMenu *) 0 ;
41004 wxString *arg3 = 0 ;
41005 bool result;
41006 void *argp1 = 0 ;
41007 int res1 = 0 ;
41008 void *argp2 = 0 ;
41009 int res2 = 0 ;
41010 bool temp3 = false ;
41011 PyObject * obj0 = 0 ;
41012 PyObject * obj1 = 0 ;
41013 PyObject * obj2 = 0 ;
41014 char * kwnames[] = {
41015 (char *) "self",(char *) "menu",(char *) "title", NULL
41016 };
41017
41018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41020 if (!SWIG_IsOK(res1)) {
41021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41022 }
41023 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41024 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41025 if (!SWIG_IsOK(res2)) {
41026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41027 }
41028 arg2 = reinterpret_cast< wxMenu * >(argp2);
41029 {
41030 arg3 = wxString_in_helper(obj2);
41031 if (arg3 == NULL) SWIG_fail;
41032 temp3 = true;
41033 }
41034 {
41035 PyThreadState* __tstate = wxPyBeginAllowThreads();
41036 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41037 wxPyEndAllowThreads(__tstate);
41038 if (PyErr_Occurred()) SWIG_fail;
41039 }
41040 {
41041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41042 }
41043 {
41044 if (temp3)
41045 delete arg3;
41046 }
41047 return resultobj;
41048 fail:
41049 {
41050 if (temp3)
41051 delete arg3;
41052 }
41053 return NULL;
41054 }
41055
41056
41057 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41058 PyObject *resultobj = 0;
41059 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41060 size_t arg2 ;
41061 wxMenu *arg3 = (wxMenu *) 0 ;
41062 wxString *arg4 = 0 ;
41063 bool result;
41064 void *argp1 = 0 ;
41065 int res1 = 0 ;
41066 size_t val2 ;
41067 int ecode2 = 0 ;
41068 void *argp3 = 0 ;
41069 int res3 = 0 ;
41070 bool temp4 = false ;
41071 PyObject * obj0 = 0 ;
41072 PyObject * obj1 = 0 ;
41073 PyObject * obj2 = 0 ;
41074 PyObject * obj3 = 0 ;
41075 char * kwnames[] = {
41076 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41077 };
41078
41079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41081 if (!SWIG_IsOK(res1)) {
41082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41083 }
41084 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41085 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41086 if (!SWIG_IsOK(ecode2)) {
41087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41088 }
41089 arg2 = static_cast< size_t >(val2);
41090 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41091 if (!SWIG_IsOK(res3)) {
41092 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41093 }
41094 arg3 = reinterpret_cast< wxMenu * >(argp3);
41095 {
41096 arg4 = wxString_in_helper(obj3);
41097 if (arg4 == NULL) SWIG_fail;
41098 temp4 = true;
41099 }
41100 {
41101 PyThreadState* __tstate = wxPyBeginAllowThreads();
41102 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41103 wxPyEndAllowThreads(__tstate);
41104 if (PyErr_Occurred()) SWIG_fail;
41105 }
41106 {
41107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41108 }
41109 {
41110 if (temp4)
41111 delete arg4;
41112 }
41113 return resultobj;
41114 fail:
41115 {
41116 if (temp4)
41117 delete arg4;
41118 }
41119 return NULL;
41120 }
41121
41122
41123 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41124 PyObject *resultobj = 0;
41125 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41126 size_t result;
41127 void *argp1 = 0 ;
41128 int res1 = 0 ;
41129 PyObject *swig_obj[1] ;
41130
41131 if (!args) SWIG_fail;
41132 swig_obj[0] = args;
41133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41134 if (!SWIG_IsOK(res1)) {
41135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41136 }
41137 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41138 {
41139 PyThreadState* __tstate = wxPyBeginAllowThreads();
41140 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41141 wxPyEndAllowThreads(__tstate);
41142 if (PyErr_Occurred()) SWIG_fail;
41143 }
41144 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41145 return resultobj;
41146 fail:
41147 return NULL;
41148 }
41149
41150
41151 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41152 PyObject *resultobj = 0;
41153 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41154 size_t arg2 ;
41155 wxMenu *result = 0 ;
41156 void *argp1 = 0 ;
41157 int res1 = 0 ;
41158 size_t val2 ;
41159 int ecode2 = 0 ;
41160 PyObject * obj0 = 0 ;
41161 PyObject * obj1 = 0 ;
41162 char * kwnames[] = {
41163 (char *) "self",(char *) "pos", NULL
41164 };
41165
41166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41168 if (!SWIG_IsOK(res1)) {
41169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41170 }
41171 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41172 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41173 if (!SWIG_IsOK(ecode2)) {
41174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41175 }
41176 arg2 = static_cast< size_t >(val2);
41177 {
41178 PyThreadState* __tstate = wxPyBeginAllowThreads();
41179 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41180 wxPyEndAllowThreads(__tstate);
41181 if (PyErr_Occurred()) SWIG_fail;
41182 }
41183 {
41184 resultobj = wxPyMake_wxObject(result, 0);
41185 }
41186 return resultobj;
41187 fail:
41188 return NULL;
41189 }
41190
41191
41192 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41193 PyObject *resultobj = 0;
41194 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41195 size_t arg2 ;
41196 wxMenu *arg3 = (wxMenu *) 0 ;
41197 wxString *arg4 = 0 ;
41198 wxMenu *result = 0 ;
41199 void *argp1 = 0 ;
41200 int res1 = 0 ;
41201 size_t val2 ;
41202 int ecode2 = 0 ;
41203 void *argp3 = 0 ;
41204 int res3 = 0 ;
41205 bool temp4 = false ;
41206 PyObject * obj0 = 0 ;
41207 PyObject * obj1 = 0 ;
41208 PyObject * obj2 = 0 ;
41209 PyObject * obj3 = 0 ;
41210 char * kwnames[] = {
41211 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41212 };
41213
41214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41216 if (!SWIG_IsOK(res1)) {
41217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41218 }
41219 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41220 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41221 if (!SWIG_IsOK(ecode2)) {
41222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41223 }
41224 arg2 = static_cast< size_t >(val2);
41225 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41226 if (!SWIG_IsOK(res3)) {
41227 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41228 }
41229 arg3 = reinterpret_cast< wxMenu * >(argp3);
41230 {
41231 arg4 = wxString_in_helper(obj3);
41232 if (arg4 == NULL) SWIG_fail;
41233 temp4 = true;
41234 }
41235 {
41236 PyThreadState* __tstate = wxPyBeginAllowThreads();
41237 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41238 wxPyEndAllowThreads(__tstate);
41239 if (PyErr_Occurred()) SWIG_fail;
41240 }
41241 {
41242 resultobj = wxPyMake_wxObject(result, 0);
41243 }
41244 {
41245 if (temp4)
41246 delete arg4;
41247 }
41248 return resultobj;
41249 fail:
41250 {
41251 if (temp4)
41252 delete arg4;
41253 }
41254 return NULL;
41255 }
41256
41257
41258 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41259 PyObject *resultobj = 0;
41260 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41261 size_t arg2 ;
41262 wxMenu *result = 0 ;
41263 void *argp1 = 0 ;
41264 int res1 = 0 ;
41265 size_t val2 ;
41266 int ecode2 = 0 ;
41267 PyObject * obj0 = 0 ;
41268 PyObject * obj1 = 0 ;
41269 char * kwnames[] = {
41270 (char *) "self",(char *) "pos", NULL
41271 };
41272
41273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41275 if (!SWIG_IsOK(res1)) {
41276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41277 }
41278 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41279 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41280 if (!SWIG_IsOK(ecode2)) {
41281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41282 }
41283 arg2 = static_cast< size_t >(val2);
41284 {
41285 PyThreadState* __tstate = wxPyBeginAllowThreads();
41286 result = (wxMenu *)(arg1)->Remove(arg2);
41287 wxPyEndAllowThreads(__tstate);
41288 if (PyErr_Occurred()) SWIG_fail;
41289 }
41290 {
41291 resultobj = wxPyMake_wxObject(result, 0);
41292 }
41293 return resultobj;
41294 fail:
41295 return NULL;
41296 }
41297
41298
41299 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41300 PyObject *resultobj = 0;
41301 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41302 size_t arg2 ;
41303 bool arg3 ;
41304 void *argp1 = 0 ;
41305 int res1 = 0 ;
41306 size_t val2 ;
41307 int ecode2 = 0 ;
41308 bool val3 ;
41309 int ecode3 = 0 ;
41310 PyObject * obj0 = 0 ;
41311 PyObject * obj1 = 0 ;
41312 PyObject * obj2 = 0 ;
41313 char * kwnames[] = {
41314 (char *) "self",(char *) "pos",(char *) "enable", NULL
41315 };
41316
41317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41319 if (!SWIG_IsOK(res1)) {
41320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41321 }
41322 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41323 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41324 if (!SWIG_IsOK(ecode2)) {
41325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41326 }
41327 arg2 = static_cast< size_t >(val2);
41328 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41329 if (!SWIG_IsOK(ecode3)) {
41330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41331 }
41332 arg3 = static_cast< bool >(val3);
41333 {
41334 PyThreadState* __tstate = wxPyBeginAllowThreads();
41335 (arg1)->EnableTop(arg2,arg3);
41336 wxPyEndAllowThreads(__tstate);
41337 if (PyErr_Occurred()) SWIG_fail;
41338 }
41339 resultobj = SWIG_Py_Void();
41340 return resultobj;
41341 fail:
41342 return NULL;
41343 }
41344
41345
41346 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41347 PyObject *resultobj = 0;
41348 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41349 size_t arg2 ;
41350 bool result;
41351 void *argp1 = 0 ;
41352 int res1 = 0 ;
41353 size_t val2 ;
41354 int ecode2 = 0 ;
41355 PyObject * obj0 = 0 ;
41356 PyObject * obj1 = 0 ;
41357 char * kwnames[] = {
41358 (char *) "self",(char *) "pos", NULL
41359 };
41360
41361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41363 if (!SWIG_IsOK(res1)) {
41364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41365 }
41366 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41367 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41368 if (!SWIG_IsOK(ecode2)) {
41369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41370 }
41371 arg2 = static_cast< size_t >(val2);
41372 {
41373 PyThreadState* __tstate = wxPyBeginAllowThreads();
41374 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41375 wxPyEndAllowThreads(__tstate);
41376 if (PyErr_Occurred()) SWIG_fail;
41377 }
41378 {
41379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41380 }
41381 return resultobj;
41382 fail:
41383 return NULL;
41384 }
41385
41386
41387 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41388 PyObject *resultobj = 0;
41389 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41390 size_t arg2 ;
41391 wxString *arg3 = 0 ;
41392 void *argp1 = 0 ;
41393 int res1 = 0 ;
41394 size_t val2 ;
41395 int ecode2 = 0 ;
41396 bool temp3 = false ;
41397 PyObject * obj0 = 0 ;
41398 PyObject * obj1 = 0 ;
41399 PyObject * obj2 = 0 ;
41400 char * kwnames[] = {
41401 (char *) "self",(char *) "pos",(char *) "label", NULL
41402 };
41403
41404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41406 if (!SWIG_IsOK(res1)) {
41407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41408 }
41409 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41410 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41411 if (!SWIG_IsOK(ecode2)) {
41412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41413 }
41414 arg2 = static_cast< size_t >(val2);
41415 {
41416 arg3 = wxString_in_helper(obj2);
41417 if (arg3 == NULL) SWIG_fail;
41418 temp3 = true;
41419 }
41420 {
41421 PyThreadState* __tstate = wxPyBeginAllowThreads();
41422 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41423 wxPyEndAllowThreads(__tstate);
41424 if (PyErr_Occurred()) SWIG_fail;
41425 }
41426 resultobj = SWIG_Py_Void();
41427 {
41428 if (temp3)
41429 delete arg3;
41430 }
41431 return resultobj;
41432 fail:
41433 {
41434 if (temp3)
41435 delete arg3;
41436 }
41437 return NULL;
41438 }
41439
41440
41441 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41442 PyObject *resultobj = 0;
41443 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41444 size_t arg2 ;
41445 wxString result;
41446 void *argp1 = 0 ;
41447 int res1 = 0 ;
41448 size_t val2 ;
41449 int ecode2 = 0 ;
41450 PyObject * obj0 = 0 ;
41451 PyObject * obj1 = 0 ;
41452 char * kwnames[] = {
41453 (char *) "self",(char *) "pos", NULL
41454 };
41455
41456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41458 if (!SWIG_IsOK(res1)) {
41459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41460 }
41461 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41462 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41463 if (!SWIG_IsOK(ecode2)) {
41464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41465 }
41466 arg2 = static_cast< size_t >(val2);
41467 {
41468 PyThreadState* __tstate = wxPyBeginAllowThreads();
41469 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41470 wxPyEndAllowThreads(__tstate);
41471 if (PyErr_Occurred()) SWIG_fail;
41472 }
41473 {
41474 #if wxUSE_UNICODE
41475 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41476 #else
41477 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41478 #endif
41479 }
41480 return resultobj;
41481 fail:
41482 return NULL;
41483 }
41484
41485
41486 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41487 PyObject *resultobj = 0;
41488 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41489 wxString *arg2 = 0 ;
41490 wxString *arg3 = 0 ;
41491 int result;
41492 void *argp1 = 0 ;
41493 int res1 = 0 ;
41494 bool temp2 = false ;
41495 bool temp3 = false ;
41496 PyObject * obj0 = 0 ;
41497 PyObject * obj1 = 0 ;
41498 PyObject * obj2 = 0 ;
41499 char * kwnames[] = {
41500 (char *) "self",(char *) "menu",(char *) "item", NULL
41501 };
41502
41503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41505 if (!SWIG_IsOK(res1)) {
41506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41507 }
41508 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41509 {
41510 arg2 = wxString_in_helper(obj1);
41511 if (arg2 == NULL) SWIG_fail;
41512 temp2 = true;
41513 }
41514 {
41515 arg3 = wxString_in_helper(obj2);
41516 if (arg3 == NULL) SWIG_fail;
41517 temp3 = true;
41518 }
41519 {
41520 PyThreadState* __tstate = wxPyBeginAllowThreads();
41521 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41522 wxPyEndAllowThreads(__tstate);
41523 if (PyErr_Occurred()) SWIG_fail;
41524 }
41525 resultobj = SWIG_From_int(static_cast< int >(result));
41526 {
41527 if (temp2)
41528 delete arg2;
41529 }
41530 {
41531 if (temp3)
41532 delete arg3;
41533 }
41534 return resultobj;
41535 fail:
41536 {
41537 if (temp2)
41538 delete arg2;
41539 }
41540 {
41541 if (temp3)
41542 delete arg3;
41543 }
41544 return NULL;
41545 }
41546
41547
41548 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41549 PyObject *resultobj = 0;
41550 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41551 int arg2 ;
41552 wxMenuItem *result = 0 ;
41553 void *argp1 = 0 ;
41554 int res1 = 0 ;
41555 int val2 ;
41556 int ecode2 = 0 ;
41557 PyObject * obj0 = 0 ;
41558 PyObject * obj1 = 0 ;
41559 char * kwnames[] = {
41560 (char *) "self",(char *) "id", NULL
41561 };
41562
41563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41565 if (!SWIG_IsOK(res1)) {
41566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41567 }
41568 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41569 ecode2 = SWIG_AsVal_int(obj1, &val2);
41570 if (!SWIG_IsOK(ecode2)) {
41571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41572 }
41573 arg2 = static_cast< int >(val2);
41574 {
41575 PyThreadState* __tstate = wxPyBeginAllowThreads();
41576 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41577 wxPyEndAllowThreads(__tstate);
41578 if (PyErr_Occurred()) SWIG_fail;
41579 }
41580 {
41581 resultobj = wxPyMake_wxObject(result, (bool)0);
41582 }
41583 return resultobj;
41584 fail:
41585 return NULL;
41586 }
41587
41588
41589 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41590 PyObject *resultobj = 0;
41591 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41592 wxString *arg2 = 0 ;
41593 int result;
41594 void *argp1 = 0 ;
41595 int res1 = 0 ;
41596 bool temp2 = false ;
41597 PyObject * obj0 = 0 ;
41598 PyObject * obj1 = 0 ;
41599 char * kwnames[] = {
41600 (char *) "self",(char *) "title", NULL
41601 };
41602
41603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41605 if (!SWIG_IsOK(res1)) {
41606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41607 }
41608 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41609 {
41610 arg2 = wxString_in_helper(obj1);
41611 if (arg2 == NULL) SWIG_fail;
41612 temp2 = true;
41613 }
41614 {
41615 PyThreadState* __tstate = wxPyBeginAllowThreads();
41616 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41617 wxPyEndAllowThreads(__tstate);
41618 if (PyErr_Occurred()) SWIG_fail;
41619 }
41620 resultobj = SWIG_From_int(static_cast< int >(result));
41621 {
41622 if (temp2)
41623 delete arg2;
41624 }
41625 return resultobj;
41626 fail:
41627 {
41628 if (temp2)
41629 delete arg2;
41630 }
41631 return NULL;
41632 }
41633
41634
41635 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41636 PyObject *resultobj = 0;
41637 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41638 int arg2 ;
41639 bool arg3 ;
41640 void *argp1 = 0 ;
41641 int res1 = 0 ;
41642 int val2 ;
41643 int ecode2 = 0 ;
41644 bool val3 ;
41645 int ecode3 = 0 ;
41646 PyObject * obj0 = 0 ;
41647 PyObject * obj1 = 0 ;
41648 PyObject * obj2 = 0 ;
41649 char * kwnames[] = {
41650 (char *) "self",(char *) "id",(char *) "enable", NULL
41651 };
41652
41653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41655 if (!SWIG_IsOK(res1)) {
41656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41657 }
41658 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41659 ecode2 = SWIG_AsVal_int(obj1, &val2);
41660 if (!SWIG_IsOK(ecode2)) {
41661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41662 }
41663 arg2 = static_cast< int >(val2);
41664 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41665 if (!SWIG_IsOK(ecode3)) {
41666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41667 }
41668 arg3 = static_cast< bool >(val3);
41669 {
41670 PyThreadState* __tstate = wxPyBeginAllowThreads();
41671 (arg1)->Enable(arg2,arg3);
41672 wxPyEndAllowThreads(__tstate);
41673 if (PyErr_Occurred()) SWIG_fail;
41674 }
41675 resultobj = SWIG_Py_Void();
41676 return resultobj;
41677 fail:
41678 return NULL;
41679 }
41680
41681
41682 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41683 PyObject *resultobj = 0;
41684 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41685 int arg2 ;
41686 bool arg3 ;
41687 void *argp1 = 0 ;
41688 int res1 = 0 ;
41689 int val2 ;
41690 int ecode2 = 0 ;
41691 bool val3 ;
41692 int ecode3 = 0 ;
41693 PyObject * obj0 = 0 ;
41694 PyObject * obj1 = 0 ;
41695 PyObject * obj2 = 0 ;
41696 char * kwnames[] = {
41697 (char *) "self",(char *) "id",(char *) "check", NULL
41698 };
41699
41700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41702 if (!SWIG_IsOK(res1)) {
41703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41704 }
41705 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41706 ecode2 = SWIG_AsVal_int(obj1, &val2);
41707 if (!SWIG_IsOK(ecode2)) {
41708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41709 }
41710 arg2 = static_cast< int >(val2);
41711 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41712 if (!SWIG_IsOK(ecode3)) {
41713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41714 }
41715 arg3 = static_cast< bool >(val3);
41716 {
41717 PyThreadState* __tstate = wxPyBeginAllowThreads();
41718 (arg1)->Check(arg2,arg3);
41719 wxPyEndAllowThreads(__tstate);
41720 if (PyErr_Occurred()) SWIG_fail;
41721 }
41722 resultobj = SWIG_Py_Void();
41723 return resultobj;
41724 fail:
41725 return NULL;
41726 }
41727
41728
41729 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41730 PyObject *resultobj = 0;
41731 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41732 int arg2 ;
41733 bool result;
41734 void *argp1 = 0 ;
41735 int res1 = 0 ;
41736 int val2 ;
41737 int ecode2 = 0 ;
41738 PyObject * obj0 = 0 ;
41739 PyObject * obj1 = 0 ;
41740 char * kwnames[] = {
41741 (char *) "self",(char *) "id", NULL
41742 };
41743
41744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41746 if (!SWIG_IsOK(res1)) {
41747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41748 }
41749 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41750 ecode2 = SWIG_AsVal_int(obj1, &val2);
41751 if (!SWIG_IsOK(ecode2)) {
41752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41753 }
41754 arg2 = static_cast< int >(val2);
41755 {
41756 PyThreadState* __tstate = wxPyBeginAllowThreads();
41757 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41758 wxPyEndAllowThreads(__tstate);
41759 if (PyErr_Occurred()) SWIG_fail;
41760 }
41761 {
41762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41763 }
41764 return resultobj;
41765 fail:
41766 return NULL;
41767 }
41768
41769
41770 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41771 PyObject *resultobj = 0;
41772 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41773 int arg2 ;
41774 bool result;
41775 void *argp1 = 0 ;
41776 int res1 = 0 ;
41777 int val2 ;
41778 int ecode2 = 0 ;
41779 PyObject * obj0 = 0 ;
41780 PyObject * obj1 = 0 ;
41781 char * kwnames[] = {
41782 (char *) "self",(char *) "id", NULL
41783 };
41784
41785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41787 if (!SWIG_IsOK(res1)) {
41788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41789 }
41790 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41791 ecode2 = SWIG_AsVal_int(obj1, &val2);
41792 if (!SWIG_IsOK(ecode2)) {
41793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41794 }
41795 arg2 = static_cast< int >(val2);
41796 {
41797 PyThreadState* __tstate = wxPyBeginAllowThreads();
41798 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41799 wxPyEndAllowThreads(__tstate);
41800 if (PyErr_Occurred()) SWIG_fail;
41801 }
41802 {
41803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41804 }
41805 return resultobj;
41806 fail:
41807 return NULL;
41808 }
41809
41810
41811 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41812 PyObject *resultobj = 0;
41813 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41814 int arg2 ;
41815 wxString *arg3 = 0 ;
41816 void *argp1 = 0 ;
41817 int res1 = 0 ;
41818 int val2 ;
41819 int ecode2 = 0 ;
41820 bool temp3 = false ;
41821 PyObject * obj0 = 0 ;
41822 PyObject * obj1 = 0 ;
41823 PyObject * obj2 = 0 ;
41824 char * kwnames[] = {
41825 (char *) "self",(char *) "id",(char *) "label", NULL
41826 };
41827
41828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41830 if (!SWIG_IsOK(res1)) {
41831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41832 }
41833 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41834 ecode2 = SWIG_AsVal_int(obj1, &val2);
41835 if (!SWIG_IsOK(ecode2)) {
41836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41837 }
41838 arg2 = static_cast< int >(val2);
41839 {
41840 arg3 = wxString_in_helper(obj2);
41841 if (arg3 == NULL) SWIG_fail;
41842 temp3 = true;
41843 }
41844 {
41845 PyThreadState* __tstate = wxPyBeginAllowThreads();
41846 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41847 wxPyEndAllowThreads(__tstate);
41848 if (PyErr_Occurred()) SWIG_fail;
41849 }
41850 resultobj = SWIG_Py_Void();
41851 {
41852 if (temp3)
41853 delete arg3;
41854 }
41855 return resultobj;
41856 fail:
41857 {
41858 if (temp3)
41859 delete arg3;
41860 }
41861 return NULL;
41862 }
41863
41864
41865 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41866 PyObject *resultobj = 0;
41867 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41868 int arg2 ;
41869 wxString result;
41870 void *argp1 = 0 ;
41871 int res1 = 0 ;
41872 int val2 ;
41873 int ecode2 = 0 ;
41874 PyObject * obj0 = 0 ;
41875 PyObject * obj1 = 0 ;
41876 char * kwnames[] = {
41877 (char *) "self",(char *) "id", NULL
41878 };
41879
41880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41882 if (!SWIG_IsOK(res1)) {
41883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41884 }
41885 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41886 ecode2 = SWIG_AsVal_int(obj1, &val2);
41887 if (!SWIG_IsOK(ecode2)) {
41888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41889 }
41890 arg2 = static_cast< int >(val2);
41891 {
41892 PyThreadState* __tstate = wxPyBeginAllowThreads();
41893 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41894 wxPyEndAllowThreads(__tstate);
41895 if (PyErr_Occurred()) SWIG_fail;
41896 }
41897 {
41898 #if wxUSE_UNICODE
41899 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41900 #else
41901 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41902 #endif
41903 }
41904 return resultobj;
41905 fail:
41906 return NULL;
41907 }
41908
41909
41910 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41911 PyObject *resultobj = 0;
41912 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41913 int arg2 ;
41914 wxString *arg3 = 0 ;
41915 void *argp1 = 0 ;
41916 int res1 = 0 ;
41917 int val2 ;
41918 int ecode2 = 0 ;
41919 bool temp3 = false ;
41920 PyObject * obj0 = 0 ;
41921 PyObject * obj1 = 0 ;
41922 PyObject * obj2 = 0 ;
41923 char * kwnames[] = {
41924 (char *) "self",(char *) "id",(char *) "helpString", NULL
41925 };
41926
41927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41929 if (!SWIG_IsOK(res1)) {
41930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41931 }
41932 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41933 ecode2 = SWIG_AsVal_int(obj1, &val2);
41934 if (!SWIG_IsOK(ecode2)) {
41935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41936 }
41937 arg2 = static_cast< int >(val2);
41938 {
41939 arg3 = wxString_in_helper(obj2);
41940 if (arg3 == NULL) SWIG_fail;
41941 temp3 = true;
41942 }
41943 {
41944 PyThreadState* __tstate = wxPyBeginAllowThreads();
41945 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41946 wxPyEndAllowThreads(__tstate);
41947 if (PyErr_Occurred()) SWIG_fail;
41948 }
41949 resultobj = SWIG_Py_Void();
41950 {
41951 if (temp3)
41952 delete arg3;
41953 }
41954 return resultobj;
41955 fail:
41956 {
41957 if (temp3)
41958 delete arg3;
41959 }
41960 return NULL;
41961 }
41962
41963
41964 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41965 PyObject *resultobj = 0;
41966 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41967 int arg2 ;
41968 wxString result;
41969 void *argp1 = 0 ;
41970 int res1 = 0 ;
41971 int val2 ;
41972 int ecode2 = 0 ;
41973 PyObject * obj0 = 0 ;
41974 PyObject * obj1 = 0 ;
41975 char * kwnames[] = {
41976 (char *) "self",(char *) "id", NULL
41977 };
41978
41979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41981 if (!SWIG_IsOK(res1)) {
41982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41983 }
41984 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41985 ecode2 = SWIG_AsVal_int(obj1, &val2);
41986 if (!SWIG_IsOK(ecode2)) {
41987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41988 }
41989 arg2 = static_cast< int >(val2);
41990 {
41991 PyThreadState* __tstate = wxPyBeginAllowThreads();
41992 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41993 wxPyEndAllowThreads(__tstate);
41994 if (PyErr_Occurred()) SWIG_fail;
41995 }
41996 {
41997 #if wxUSE_UNICODE
41998 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41999 #else
42000 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42001 #endif
42002 }
42003 return resultobj;
42004 fail:
42005 return NULL;
42006 }
42007
42008
42009 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42010 PyObject *resultobj = 0;
42011 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42012 wxFrame *result = 0 ;
42013 void *argp1 = 0 ;
42014 int res1 = 0 ;
42015 PyObject *swig_obj[1] ;
42016
42017 if (!args) SWIG_fail;
42018 swig_obj[0] = args;
42019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42020 if (!SWIG_IsOK(res1)) {
42021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42022 }
42023 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42024 {
42025 PyThreadState* __tstate = wxPyBeginAllowThreads();
42026 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42027 wxPyEndAllowThreads(__tstate);
42028 if (PyErr_Occurred()) SWIG_fail;
42029 }
42030 {
42031 resultobj = wxPyMake_wxObject(result, (bool)0);
42032 }
42033 return resultobj;
42034 fail:
42035 return NULL;
42036 }
42037
42038
42039 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42040 PyObject *resultobj = 0;
42041 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42042 bool result;
42043 void *argp1 = 0 ;
42044 int res1 = 0 ;
42045 PyObject *swig_obj[1] ;
42046
42047 if (!args) SWIG_fail;
42048 swig_obj[0] = args;
42049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42050 if (!SWIG_IsOK(res1)) {
42051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42052 }
42053 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42054 {
42055 PyThreadState* __tstate = wxPyBeginAllowThreads();
42056 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42057 wxPyEndAllowThreads(__tstate);
42058 if (PyErr_Occurred()) SWIG_fail;
42059 }
42060 {
42061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42062 }
42063 return resultobj;
42064 fail:
42065 return NULL;
42066 }
42067
42068
42069 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42070 PyObject *resultobj = 0;
42071 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42072 wxFrame *arg2 = (wxFrame *) 0 ;
42073 void *argp1 = 0 ;
42074 int res1 = 0 ;
42075 void *argp2 = 0 ;
42076 int res2 = 0 ;
42077 PyObject * obj0 = 0 ;
42078 PyObject * obj1 = 0 ;
42079 char * kwnames[] = {
42080 (char *) "self",(char *) "frame", NULL
42081 };
42082
42083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42085 if (!SWIG_IsOK(res1)) {
42086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42087 }
42088 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42089 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42090 if (!SWIG_IsOK(res2)) {
42091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42092 }
42093 arg2 = reinterpret_cast< wxFrame * >(argp2);
42094 {
42095 PyThreadState* __tstate = wxPyBeginAllowThreads();
42096 (arg1)->Attach(arg2);
42097 wxPyEndAllowThreads(__tstate);
42098 if (PyErr_Occurred()) SWIG_fail;
42099 }
42100 resultobj = SWIG_Py_Void();
42101 return resultobj;
42102 fail:
42103 return NULL;
42104 }
42105
42106
42107 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42108 PyObject *resultobj = 0;
42109 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42110 void *argp1 = 0 ;
42111 int res1 = 0 ;
42112 PyObject *swig_obj[1] ;
42113
42114 if (!args) SWIG_fail;
42115 swig_obj[0] = args;
42116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42117 if (!SWIG_IsOK(res1)) {
42118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42119 }
42120 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42121 {
42122 PyThreadState* __tstate = wxPyBeginAllowThreads();
42123 (arg1)->Detach();
42124 wxPyEndAllowThreads(__tstate);
42125 if (PyErr_Occurred()) SWIG_fail;
42126 }
42127 resultobj = SWIG_Py_Void();
42128 return resultobj;
42129 fail:
42130 return NULL;
42131 }
42132
42133
42134 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42135 PyObject *resultobj = 0;
42136 bool arg1 ;
42137 bool val1 ;
42138 int ecode1 = 0 ;
42139 PyObject * obj0 = 0 ;
42140 char * kwnames[] = {
42141 (char *) "enable", NULL
42142 };
42143
42144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42145 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42146 if (!SWIG_IsOK(ecode1)) {
42147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42148 }
42149 arg1 = static_cast< bool >(val1);
42150 {
42151 PyThreadState* __tstate = wxPyBeginAllowThreads();
42152 wxMenuBar_SetAutoWindowMenu(arg1);
42153 wxPyEndAllowThreads(__tstate);
42154 if (PyErr_Occurred()) SWIG_fail;
42155 }
42156 resultobj = SWIG_Py_Void();
42157 return resultobj;
42158 fail:
42159 return NULL;
42160 }
42161
42162
42163 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42164 PyObject *resultobj = 0;
42165 bool result;
42166
42167 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42168 {
42169 PyThreadState* __tstate = wxPyBeginAllowThreads();
42170 result = (bool)wxMenuBar_GetAutoWindowMenu();
42171 wxPyEndAllowThreads(__tstate);
42172 if (PyErr_Occurred()) SWIG_fail;
42173 }
42174 {
42175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42176 }
42177 return resultobj;
42178 fail:
42179 return NULL;
42180 }
42181
42182
42183 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42184 PyObject *obj;
42185 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42186 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42187 return SWIG_Py_Void();
42188 }
42189
42190 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42191 return SWIG_Python_InitShadowInstance(args);
42192 }
42193
42194 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42195 PyObject *resultobj = 0;
42196 wxMenu *arg1 = (wxMenu *) NULL ;
42197 int arg2 = (int) wxID_ANY ;
42198 wxString const &arg3_defvalue = wxPyEmptyString ;
42199 wxString *arg3 = (wxString *) &arg3_defvalue ;
42200 wxString const &arg4_defvalue = wxPyEmptyString ;
42201 wxString *arg4 = (wxString *) &arg4_defvalue ;
42202 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42203 wxMenu *arg6 = (wxMenu *) NULL ;
42204 wxMenuItem *result = 0 ;
42205 void *argp1 = 0 ;
42206 int res1 = 0 ;
42207 int val2 ;
42208 int ecode2 = 0 ;
42209 bool temp3 = false ;
42210 bool temp4 = false ;
42211 int val5 ;
42212 int ecode5 = 0 ;
42213 void *argp6 = 0 ;
42214 int res6 = 0 ;
42215 PyObject * obj0 = 0 ;
42216 PyObject * obj1 = 0 ;
42217 PyObject * obj2 = 0 ;
42218 PyObject * obj3 = 0 ;
42219 PyObject * obj4 = 0 ;
42220 PyObject * obj5 = 0 ;
42221 char * kwnames[] = {
42222 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42223 };
42224
42225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42226 if (obj0) {
42227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42228 if (!SWIG_IsOK(res1)) {
42229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42230 }
42231 arg1 = reinterpret_cast< wxMenu * >(argp1);
42232 }
42233 if (obj1) {
42234 ecode2 = SWIG_AsVal_int(obj1, &val2);
42235 if (!SWIG_IsOK(ecode2)) {
42236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42237 }
42238 arg2 = static_cast< int >(val2);
42239 }
42240 if (obj2) {
42241 {
42242 arg3 = wxString_in_helper(obj2);
42243 if (arg3 == NULL) SWIG_fail;
42244 temp3 = true;
42245 }
42246 }
42247 if (obj3) {
42248 {
42249 arg4 = wxString_in_helper(obj3);
42250 if (arg4 == NULL) SWIG_fail;
42251 temp4 = true;
42252 }
42253 }
42254 if (obj4) {
42255 ecode5 = SWIG_AsVal_int(obj4, &val5);
42256 if (!SWIG_IsOK(ecode5)) {
42257 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42258 }
42259 arg5 = static_cast< wxItemKind >(val5);
42260 }
42261 if (obj5) {
42262 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42263 if (!SWIG_IsOK(res6)) {
42264 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42265 }
42266 arg6 = reinterpret_cast< wxMenu * >(argp6);
42267 }
42268 {
42269 PyThreadState* __tstate = wxPyBeginAllowThreads();
42270 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42271 wxPyEndAllowThreads(__tstate);
42272 if (PyErr_Occurred()) SWIG_fail;
42273 }
42274 {
42275 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42276 }
42277 {
42278 if (temp3)
42279 delete arg3;
42280 }
42281 {
42282 if (temp4)
42283 delete arg4;
42284 }
42285 return resultobj;
42286 fail:
42287 {
42288 if (temp3)
42289 delete arg3;
42290 }
42291 {
42292 if (temp4)
42293 delete arg4;
42294 }
42295 return NULL;
42296 }
42297
42298
42299 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42300 PyObject *resultobj = 0;
42301 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42302 void *argp1 = 0 ;
42303 int res1 = 0 ;
42304 PyObject *swig_obj[1] ;
42305
42306 if (!args) SWIG_fail;
42307 swig_obj[0] = args;
42308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42309 if (!SWIG_IsOK(res1)) {
42310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42311 }
42312 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42313 {
42314 PyThreadState* __tstate = wxPyBeginAllowThreads();
42315 delete arg1;
42316
42317 wxPyEndAllowThreads(__tstate);
42318 if (PyErr_Occurred()) SWIG_fail;
42319 }
42320 resultobj = SWIG_Py_Void();
42321 return resultobj;
42322 fail:
42323 return NULL;
42324 }
42325
42326
42327 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42328 PyObject *resultobj = 0;
42329 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42330 wxMenu *result = 0 ;
42331 void *argp1 = 0 ;
42332 int res1 = 0 ;
42333 PyObject *swig_obj[1] ;
42334
42335 if (!args) SWIG_fail;
42336 swig_obj[0] = args;
42337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42338 if (!SWIG_IsOK(res1)) {
42339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42340 }
42341 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42342 {
42343 PyThreadState* __tstate = wxPyBeginAllowThreads();
42344 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42345 wxPyEndAllowThreads(__tstate);
42346 if (PyErr_Occurred()) SWIG_fail;
42347 }
42348 {
42349 resultobj = wxPyMake_wxObject(result, 0);
42350 }
42351 return resultobj;
42352 fail:
42353 return NULL;
42354 }
42355
42356
42357 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42358 PyObject *resultobj = 0;
42359 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42360 wxMenu *arg2 = (wxMenu *) 0 ;
42361 void *argp1 = 0 ;
42362 int res1 = 0 ;
42363 void *argp2 = 0 ;
42364 int res2 = 0 ;
42365 PyObject * obj0 = 0 ;
42366 PyObject * obj1 = 0 ;
42367 char * kwnames[] = {
42368 (char *) "self",(char *) "menu", NULL
42369 };
42370
42371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42373 if (!SWIG_IsOK(res1)) {
42374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42375 }
42376 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42378 if (!SWIG_IsOK(res2)) {
42379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42380 }
42381 arg2 = reinterpret_cast< wxMenu * >(argp2);
42382 {
42383 PyThreadState* __tstate = wxPyBeginAllowThreads();
42384 (arg1)->SetMenu(arg2);
42385 wxPyEndAllowThreads(__tstate);
42386 if (PyErr_Occurred()) SWIG_fail;
42387 }
42388 resultobj = SWIG_Py_Void();
42389 return resultobj;
42390 fail:
42391 return NULL;
42392 }
42393
42394
42395 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42396 PyObject *resultobj = 0;
42397 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42398 int arg2 ;
42399 void *argp1 = 0 ;
42400 int res1 = 0 ;
42401 int val2 ;
42402 int ecode2 = 0 ;
42403 PyObject * obj0 = 0 ;
42404 PyObject * obj1 = 0 ;
42405 char * kwnames[] = {
42406 (char *) "self",(char *) "id", NULL
42407 };
42408
42409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42411 if (!SWIG_IsOK(res1)) {
42412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42413 }
42414 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42415 ecode2 = SWIG_AsVal_int(obj1, &val2);
42416 if (!SWIG_IsOK(ecode2)) {
42417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42418 }
42419 arg2 = static_cast< int >(val2);
42420 {
42421 PyThreadState* __tstate = wxPyBeginAllowThreads();
42422 (arg1)->SetId(arg2);
42423 wxPyEndAllowThreads(__tstate);
42424 if (PyErr_Occurred()) SWIG_fail;
42425 }
42426 resultobj = SWIG_Py_Void();
42427 return resultobj;
42428 fail:
42429 return NULL;
42430 }
42431
42432
42433 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42434 PyObject *resultobj = 0;
42435 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42436 int result;
42437 void *argp1 = 0 ;
42438 int res1 = 0 ;
42439 PyObject *swig_obj[1] ;
42440
42441 if (!args) SWIG_fail;
42442 swig_obj[0] = args;
42443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42444 if (!SWIG_IsOK(res1)) {
42445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42446 }
42447 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42448 {
42449 PyThreadState* __tstate = wxPyBeginAllowThreads();
42450 result = (int)((wxMenuItem const *)arg1)->GetId();
42451 wxPyEndAllowThreads(__tstate);
42452 if (PyErr_Occurred()) SWIG_fail;
42453 }
42454 resultobj = SWIG_From_int(static_cast< int >(result));
42455 return resultobj;
42456 fail:
42457 return NULL;
42458 }
42459
42460
42461 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42462 PyObject *resultobj = 0;
42463 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42464 bool result;
42465 void *argp1 = 0 ;
42466 int res1 = 0 ;
42467 PyObject *swig_obj[1] ;
42468
42469 if (!args) SWIG_fail;
42470 swig_obj[0] = args;
42471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42472 if (!SWIG_IsOK(res1)) {
42473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42474 }
42475 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42476 {
42477 PyThreadState* __tstate = wxPyBeginAllowThreads();
42478 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42479 wxPyEndAllowThreads(__tstate);
42480 if (PyErr_Occurred()) SWIG_fail;
42481 }
42482 {
42483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42484 }
42485 return resultobj;
42486 fail:
42487 return NULL;
42488 }
42489
42490
42491 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42492 PyObject *resultobj = 0;
42493 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42494 wxString *arg2 = 0 ;
42495 void *argp1 = 0 ;
42496 int res1 = 0 ;
42497 bool temp2 = false ;
42498 PyObject * obj0 = 0 ;
42499 PyObject * obj1 = 0 ;
42500 char * kwnames[] = {
42501 (char *) "self",(char *) "str", NULL
42502 };
42503
42504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42506 if (!SWIG_IsOK(res1)) {
42507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42508 }
42509 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42510 {
42511 arg2 = wxString_in_helper(obj1);
42512 if (arg2 == NULL) SWIG_fail;
42513 temp2 = true;
42514 }
42515 {
42516 PyThreadState* __tstate = wxPyBeginAllowThreads();
42517 (arg1)->SetText((wxString const &)*arg2);
42518 wxPyEndAllowThreads(__tstate);
42519 if (PyErr_Occurred()) SWIG_fail;
42520 }
42521 resultobj = SWIG_Py_Void();
42522 {
42523 if (temp2)
42524 delete arg2;
42525 }
42526 return resultobj;
42527 fail:
42528 {
42529 if (temp2)
42530 delete arg2;
42531 }
42532 return NULL;
42533 }
42534
42535
42536 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42537 PyObject *resultobj = 0;
42538 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42539 wxString result;
42540 void *argp1 = 0 ;
42541 int res1 = 0 ;
42542 PyObject *swig_obj[1] ;
42543
42544 if (!args) SWIG_fail;
42545 swig_obj[0] = args;
42546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42547 if (!SWIG_IsOK(res1)) {
42548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42549 }
42550 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42551 {
42552 PyThreadState* __tstate = wxPyBeginAllowThreads();
42553 result = ((wxMenuItem const *)arg1)->GetLabel();
42554 wxPyEndAllowThreads(__tstate);
42555 if (PyErr_Occurred()) SWIG_fail;
42556 }
42557 {
42558 #if wxUSE_UNICODE
42559 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42560 #else
42561 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42562 #endif
42563 }
42564 return resultobj;
42565 fail:
42566 return NULL;
42567 }
42568
42569
42570 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42571 PyObject *resultobj = 0;
42572 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42573 wxString *result = 0 ;
42574 void *argp1 = 0 ;
42575 int res1 = 0 ;
42576 PyObject *swig_obj[1] ;
42577
42578 if (!args) SWIG_fail;
42579 swig_obj[0] = args;
42580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42581 if (!SWIG_IsOK(res1)) {
42582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42583 }
42584 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42585 {
42586 PyThreadState* __tstate = wxPyBeginAllowThreads();
42587 {
42588 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42589 result = (wxString *) &_result_ref;
42590 }
42591 wxPyEndAllowThreads(__tstate);
42592 if (PyErr_Occurred()) SWIG_fail;
42593 }
42594 {
42595 #if wxUSE_UNICODE
42596 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42597 #else
42598 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42599 #endif
42600 }
42601 return resultobj;
42602 fail:
42603 return NULL;
42604 }
42605
42606
42607 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42608 PyObject *resultobj = 0;
42609 wxString *arg1 = 0 ;
42610 wxString result;
42611 bool temp1 = false ;
42612 PyObject * obj0 = 0 ;
42613 char * kwnames[] = {
42614 (char *) "text", NULL
42615 };
42616
42617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42618 {
42619 arg1 = wxString_in_helper(obj0);
42620 if (arg1 == NULL) SWIG_fail;
42621 temp1 = true;
42622 }
42623 {
42624 PyThreadState* __tstate = wxPyBeginAllowThreads();
42625 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42626 wxPyEndAllowThreads(__tstate);
42627 if (PyErr_Occurred()) SWIG_fail;
42628 }
42629 {
42630 #if wxUSE_UNICODE
42631 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42632 #else
42633 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42634 #endif
42635 }
42636 {
42637 if (temp1)
42638 delete arg1;
42639 }
42640 return resultobj;
42641 fail:
42642 {
42643 if (temp1)
42644 delete arg1;
42645 }
42646 return NULL;
42647 }
42648
42649
42650 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42651 PyObject *resultobj = 0;
42652 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42653 wxItemKind result;
42654 void *argp1 = 0 ;
42655 int res1 = 0 ;
42656 PyObject *swig_obj[1] ;
42657
42658 if (!args) SWIG_fail;
42659 swig_obj[0] = args;
42660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42661 if (!SWIG_IsOK(res1)) {
42662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42663 }
42664 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42665 {
42666 PyThreadState* __tstate = wxPyBeginAllowThreads();
42667 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42668 wxPyEndAllowThreads(__tstate);
42669 if (PyErr_Occurred()) SWIG_fail;
42670 }
42671 resultobj = SWIG_From_int(static_cast< int >(result));
42672 return resultobj;
42673 fail:
42674 return NULL;
42675 }
42676
42677
42678 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42679 PyObject *resultobj = 0;
42680 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42681 wxItemKind arg2 ;
42682 void *argp1 = 0 ;
42683 int res1 = 0 ;
42684 int val2 ;
42685 int ecode2 = 0 ;
42686 PyObject * obj0 = 0 ;
42687 PyObject * obj1 = 0 ;
42688 char * kwnames[] = {
42689 (char *) "self",(char *) "kind", NULL
42690 };
42691
42692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42694 if (!SWIG_IsOK(res1)) {
42695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42696 }
42697 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42698 ecode2 = SWIG_AsVal_int(obj1, &val2);
42699 if (!SWIG_IsOK(ecode2)) {
42700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42701 }
42702 arg2 = static_cast< wxItemKind >(val2);
42703 {
42704 PyThreadState* __tstate = wxPyBeginAllowThreads();
42705 (arg1)->SetKind(arg2);
42706 wxPyEndAllowThreads(__tstate);
42707 if (PyErr_Occurred()) SWIG_fail;
42708 }
42709 resultobj = SWIG_Py_Void();
42710 return resultobj;
42711 fail:
42712 return NULL;
42713 }
42714
42715
42716 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42717 PyObject *resultobj = 0;
42718 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42719 bool arg2 ;
42720 void *argp1 = 0 ;
42721 int res1 = 0 ;
42722 bool val2 ;
42723 int ecode2 = 0 ;
42724 PyObject * obj0 = 0 ;
42725 PyObject * obj1 = 0 ;
42726 char * kwnames[] = {
42727 (char *) "self",(char *) "checkable", NULL
42728 };
42729
42730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42732 if (!SWIG_IsOK(res1)) {
42733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42734 }
42735 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42736 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42737 if (!SWIG_IsOK(ecode2)) {
42738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42739 }
42740 arg2 = static_cast< bool >(val2);
42741 {
42742 PyThreadState* __tstate = wxPyBeginAllowThreads();
42743 (arg1)->SetCheckable(arg2);
42744 wxPyEndAllowThreads(__tstate);
42745 if (PyErr_Occurred()) SWIG_fail;
42746 }
42747 resultobj = SWIG_Py_Void();
42748 return resultobj;
42749 fail:
42750 return NULL;
42751 }
42752
42753
42754 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42755 PyObject *resultobj = 0;
42756 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42757 bool result;
42758 void *argp1 = 0 ;
42759 int res1 = 0 ;
42760 PyObject *swig_obj[1] ;
42761
42762 if (!args) SWIG_fail;
42763 swig_obj[0] = args;
42764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42765 if (!SWIG_IsOK(res1)) {
42766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42767 }
42768 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42769 {
42770 PyThreadState* __tstate = wxPyBeginAllowThreads();
42771 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42772 wxPyEndAllowThreads(__tstate);
42773 if (PyErr_Occurred()) SWIG_fail;
42774 }
42775 {
42776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42777 }
42778 return resultobj;
42779 fail:
42780 return NULL;
42781 }
42782
42783
42784 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42785 PyObject *resultobj = 0;
42786 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42787 bool result;
42788 void *argp1 = 0 ;
42789 int res1 = 0 ;
42790 PyObject *swig_obj[1] ;
42791
42792 if (!args) SWIG_fail;
42793 swig_obj[0] = args;
42794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42795 if (!SWIG_IsOK(res1)) {
42796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42797 }
42798 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42799 {
42800 PyThreadState* __tstate = wxPyBeginAllowThreads();
42801 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42802 wxPyEndAllowThreads(__tstate);
42803 if (PyErr_Occurred()) SWIG_fail;
42804 }
42805 {
42806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42807 }
42808 return resultobj;
42809 fail:
42810 return NULL;
42811 }
42812
42813
42814 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42815 PyObject *resultobj = 0;
42816 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42817 wxMenu *arg2 = (wxMenu *) 0 ;
42818 void *argp1 = 0 ;
42819 int res1 = 0 ;
42820 void *argp2 = 0 ;
42821 int res2 = 0 ;
42822 PyObject * obj0 = 0 ;
42823 PyObject * obj1 = 0 ;
42824 char * kwnames[] = {
42825 (char *) "self",(char *) "menu", NULL
42826 };
42827
42828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42830 if (!SWIG_IsOK(res1)) {
42831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42832 }
42833 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42834 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42835 if (!SWIG_IsOK(res2)) {
42836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42837 }
42838 arg2 = reinterpret_cast< wxMenu * >(argp2);
42839 {
42840 PyThreadState* __tstate = wxPyBeginAllowThreads();
42841 (arg1)->SetSubMenu(arg2);
42842 wxPyEndAllowThreads(__tstate);
42843 if (PyErr_Occurred()) SWIG_fail;
42844 }
42845 resultobj = SWIG_Py_Void();
42846 return resultobj;
42847 fail:
42848 return NULL;
42849 }
42850
42851
42852 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42853 PyObject *resultobj = 0;
42854 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42855 wxMenu *result = 0 ;
42856 void *argp1 = 0 ;
42857 int res1 = 0 ;
42858 PyObject *swig_obj[1] ;
42859
42860 if (!args) SWIG_fail;
42861 swig_obj[0] = args;
42862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42863 if (!SWIG_IsOK(res1)) {
42864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42865 }
42866 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42867 {
42868 PyThreadState* __tstate = wxPyBeginAllowThreads();
42869 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42870 wxPyEndAllowThreads(__tstate);
42871 if (PyErr_Occurred()) SWIG_fail;
42872 }
42873 {
42874 resultobj = wxPyMake_wxObject(result, 0);
42875 }
42876 return resultobj;
42877 fail:
42878 return NULL;
42879 }
42880
42881
42882 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42883 PyObject *resultobj = 0;
42884 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42885 bool arg2 = (bool) true ;
42886 void *argp1 = 0 ;
42887 int res1 = 0 ;
42888 bool val2 ;
42889 int ecode2 = 0 ;
42890 PyObject * obj0 = 0 ;
42891 PyObject * obj1 = 0 ;
42892 char * kwnames[] = {
42893 (char *) "self",(char *) "enable", NULL
42894 };
42895
42896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42898 if (!SWIG_IsOK(res1)) {
42899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42900 }
42901 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42902 if (obj1) {
42903 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42904 if (!SWIG_IsOK(ecode2)) {
42905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42906 }
42907 arg2 = static_cast< bool >(val2);
42908 }
42909 {
42910 PyThreadState* __tstate = wxPyBeginAllowThreads();
42911 (arg1)->Enable(arg2);
42912 wxPyEndAllowThreads(__tstate);
42913 if (PyErr_Occurred()) SWIG_fail;
42914 }
42915 resultobj = SWIG_Py_Void();
42916 return resultobj;
42917 fail:
42918 return NULL;
42919 }
42920
42921
42922 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42923 PyObject *resultobj = 0;
42924 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42925 bool result;
42926 void *argp1 = 0 ;
42927 int res1 = 0 ;
42928 PyObject *swig_obj[1] ;
42929
42930 if (!args) SWIG_fail;
42931 swig_obj[0] = args;
42932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42933 if (!SWIG_IsOK(res1)) {
42934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42935 }
42936 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42937 {
42938 PyThreadState* __tstate = wxPyBeginAllowThreads();
42939 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42940 wxPyEndAllowThreads(__tstate);
42941 if (PyErr_Occurred()) SWIG_fail;
42942 }
42943 {
42944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42945 }
42946 return resultobj;
42947 fail:
42948 return NULL;
42949 }
42950
42951
42952 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42953 PyObject *resultobj = 0;
42954 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42955 bool arg2 = (bool) true ;
42956 void *argp1 = 0 ;
42957 int res1 = 0 ;
42958 bool val2 ;
42959 int ecode2 = 0 ;
42960 PyObject * obj0 = 0 ;
42961 PyObject * obj1 = 0 ;
42962 char * kwnames[] = {
42963 (char *) "self",(char *) "check", NULL
42964 };
42965
42966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42968 if (!SWIG_IsOK(res1)) {
42969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42970 }
42971 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42972 if (obj1) {
42973 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42974 if (!SWIG_IsOK(ecode2)) {
42975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42976 }
42977 arg2 = static_cast< bool >(val2);
42978 }
42979 {
42980 PyThreadState* __tstate = wxPyBeginAllowThreads();
42981 (arg1)->Check(arg2);
42982 wxPyEndAllowThreads(__tstate);
42983 if (PyErr_Occurred()) SWIG_fail;
42984 }
42985 resultobj = SWIG_Py_Void();
42986 return resultobj;
42987 fail:
42988 return NULL;
42989 }
42990
42991
42992 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42993 PyObject *resultobj = 0;
42994 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42995 bool result;
42996 void *argp1 = 0 ;
42997 int res1 = 0 ;
42998 PyObject *swig_obj[1] ;
42999
43000 if (!args) SWIG_fail;
43001 swig_obj[0] = args;
43002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43003 if (!SWIG_IsOK(res1)) {
43004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43005 }
43006 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43007 {
43008 PyThreadState* __tstate = wxPyBeginAllowThreads();
43009 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43010 wxPyEndAllowThreads(__tstate);
43011 if (PyErr_Occurred()) SWIG_fail;
43012 }
43013 {
43014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43015 }
43016 return resultobj;
43017 fail:
43018 return NULL;
43019 }
43020
43021
43022 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43023 PyObject *resultobj = 0;
43024 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43025 void *argp1 = 0 ;
43026 int res1 = 0 ;
43027 PyObject *swig_obj[1] ;
43028
43029 if (!args) SWIG_fail;
43030 swig_obj[0] = args;
43031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43032 if (!SWIG_IsOK(res1)) {
43033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43034 }
43035 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43036 {
43037 PyThreadState* __tstate = wxPyBeginAllowThreads();
43038 (arg1)->Toggle();
43039 wxPyEndAllowThreads(__tstate);
43040 if (PyErr_Occurred()) SWIG_fail;
43041 }
43042 resultobj = SWIG_Py_Void();
43043 return resultobj;
43044 fail:
43045 return NULL;
43046 }
43047
43048
43049 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43050 PyObject *resultobj = 0;
43051 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43052 wxString *arg2 = 0 ;
43053 void *argp1 = 0 ;
43054 int res1 = 0 ;
43055 bool temp2 = false ;
43056 PyObject * obj0 = 0 ;
43057 PyObject * obj1 = 0 ;
43058 char * kwnames[] = {
43059 (char *) "self",(char *) "str", NULL
43060 };
43061
43062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43064 if (!SWIG_IsOK(res1)) {
43065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43066 }
43067 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43068 {
43069 arg2 = wxString_in_helper(obj1);
43070 if (arg2 == NULL) SWIG_fail;
43071 temp2 = true;
43072 }
43073 {
43074 PyThreadState* __tstate = wxPyBeginAllowThreads();
43075 (arg1)->SetHelp((wxString const &)*arg2);
43076 wxPyEndAllowThreads(__tstate);
43077 if (PyErr_Occurred()) SWIG_fail;
43078 }
43079 resultobj = SWIG_Py_Void();
43080 {
43081 if (temp2)
43082 delete arg2;
43083 }
43084 return resultobj;
43085 fail:
43086 {
43087 if (temp2)
43088 delete arg2;
43089 }
43090 return NULL;
43091 }
43092
43093
43094 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43095 PyObject *resultobj = 0;
43096 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43097 wxString *result = 0 ;
43098 void *argp1 = 0 ;
43099 int res1 = 0 ;
43100 PyObject *swig_obj[1] ;
43101
43102 if (!args) SWIG_fail;
43103 swig_obj[0] = args;
43104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43105 if (!SWIG_IsOK(res1)) {
43106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43107 }
43108 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43109 {
43110 PyThreadState* __tstate = wxPyBeginAllowThreads();
43111 {
43112 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43113 result = (wxString *) &_result_ref;
43114 }
43115 wxPyEndAllowThreads(__tstate);
43116 if (PyErr_Occurred()) SWIG_fail;
43117 }
43118 {
43119 #if wxUSE_UNICODE
43120 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43121 #else
43122 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43123 #endif
43124 }
43125 return resultobj;
43126 fail:
43127 return NULL;
43128 }
43129
43130
43131 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43132 PyObject *resultobj = 0;
43133 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43134 wxAcceleratorEntry *result = 0 ;
43135 void *argp1 = 0 ;
43136 int res1 = 0 ;
43137 PyObject *swig_obj[1] ;
43138
43139 if (!args) SWIG_fail;
43140 swig_obj[0] = args;
43141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43142 if (!SWIG_IsOK(res1)) {
43143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43144 }
43145 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43146 {
43147 PyThreadState* __tstate = wxPyBeginAllowThreads();
43148 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43149 wxPyEndAllowThreads(__tstate);
43150 if (PyErr_Occurred()) SWIG_fail;
43151 }
43152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43153 return resultobj;
43154 fail:
43155 return NULL;
43156 }
43157
43158
43159 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43160 PyObject *resultobj = 0;
43161 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43162 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43163 void *argp1 = 0 ;
43164 int res1 = 0 ;
43165 void *argp2 = 0 ;
43166 int res2 = 0 ;
43167 PyObject * obj0 = 0 ;
43168 PyObject * obj1 = 0 ;
43169 char * kwnames[] = {
43170 (char *) "self",(char *) "accel", NULL
43171 };
43172
43173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43175 if (!SWIG_IsOK(res1)) {
43176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43177 }
43178 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43179 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43180 if (!SWIG_IsOK(res2)) {
43181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43182 }
43183 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43184 {
43185 PyThreadState* __tstate = wxPyBeginAllowThreads();
43186 (arg1)->SetAccel(arg2);
43187 wxPyEndAllowThreads(__tstate);
43188 if (PyErr_Occurred()) SWIG_fail;
43189 }
43190 resultobj = SWIG_Py_Void();
43191 return resultobj;
43192 fail:
43193 return NULL;
43194 }
43195
43196
43197 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43198 PyObject *resultobj = 0;
43199 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43200 wxBitmap *arg2 = 0 ;
43201 void *argp1 = 0 ;
43202 int res1 = 0 ;
43203 void *argp2 = 0 ;
43204 int res2 = 0 ;
43205 PyObject * obj0 = 0 ;
43206 PyObject * obj1 = 0 ;
43207 char * kwnames[] = {
43208 (char *) "self",(char *) "bitmap", NULL
43209 };
43210
43211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43213 if (!SWIG_IsOK(res1)) {
43214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43215 }
43216 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43217 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43218 if (!SWIG_IsOK(res2)) {
43219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43220 }
43221 if (!argp2) {
43222 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43223 }
43224 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43225 {
43226 PyThreadState* __tstate = wxPyBeginAllowThreads();
43227 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43228 wxPyEndAllowThreads(__tstate);
43229 if (PyErr_Occurred()) SWIG_fail;
43230 }
43231 resultobj = SWIG_Py_Void();
43232 return resultobj;
43233 fail:
43234 return NULL;
43235 }
43236
43237
43238 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43239 PyObject *resultobj = 0;
43240 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43241 wxBitmap *result = 0 ;
43242 void *argp1 = 0 ;
43243 int res1 = 0 ;
43244 PyObject *swig_obj[1] ;
43245
43246 if (!args) SWIG_fail;
43247 swig_obj[0] = args;
43248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43249 if (!SWIG_IsOK(res1)) {
43250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43251 }
43252 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43253 {
43254 PyThreadState* __tstate = wxPyBeginAllowThreads();
43255 {
43256 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43257 result = (wxBitmap *) &_result_ref;
43258 }
43259 wxPyEndAllowThreads(__tstate);
43260 if (PyErr_Occurred()) SWIG_fail;
43261 }
43262 {
43263 wxBitmap* resultptr = new wxBitmap(*result);
43264 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43265 }
43266 return resultobj;
43267 fail:
43268 return NULL;
43269 }
43270
43271
43272 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43273 PyObject *resultobj = 0;
43274 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43275 wxFont *arg2 = 0 ;
43276 void *argp1 = 0 ;
43277 int res1 = 0 ;
43278 void *argp2 = 0 ;
43279 int res2 = 0 ;
43280 PyObject * obj0 = 0 ;
43281 PyObject * obj1 = 0 ;
43282 char * kwnames[] = {
43283 (char *) "self",(char *) "font", NULL
43284 };
43285
43286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43288 if (!SWIG_IsOK(res1)) {
43289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43290 }
43291 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43292 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43293 if (!SWIG_IsOK(res2)) {
43294 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43295 }
43296 if (!argp2) {
43297 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43298 }
43299 arg2 = reinterpret_cast< wxFont * >(argp2);
43300 {
43301 PyThreadState* __tstate = wxPyBeginAllowThreads();
43302 (arg1)->SetFont((wxFont const &)*arg2);
43303 wxPyEndAllowThreads(__tstate);
43304 if (PyErr_Occurred()) SWIG_fail;
43305 }
43306 resultobj = SWIG_Py_Void();
43307 return resultobj;
43308 fail:
43309 return NULL;
43310 }
43311
43312
43313 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43314 PyObject *resultobj = 0;
43315 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43316 wxFont result;
43317 void *argp1 = 0 ;
43318 int res1 = 0 ;
43319 PyObject *swig_obj[1] ;
43320
43321 if (!args) SWIG_fail;
43322 swig_obj[0] = args;
43323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43324 if (!SWIG_IsOK(res1)) {
43325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43326 }
43327 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43328 {
43329 PyThreadState* __tstate = wxPyBeginAllowThreads();
43330 result = (arg1)->GetFont();
43331 wxPyEndAllowThreads(__tstate);
43332 if (PyErr_Occurred()) SWIG_fail;
43333 }
43334 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43335 return resultobj;
43336 fail:
43337 return NULL;
43338 }
43339
43340
43341 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43342 PyObject *resultobj = 0;
43343 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43344 wxColour *arg2 = 0 ;
43345 void *argp1 = 0 ;
43346 int res1 = 0 ;
43347 wxColour temp2 ;
43348 PyObject * obj0 = 0 ;
43349 PyObject * obj1 = 0 ;
43350 char * kwnames[] = {
43351 (char *) "self",(char *) "colText", NULL
43352 };
43353
43354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43356 if (!SWIG_IsOK(res1)) {
43357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43358 }
43359 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43360 {
43361 arg2 = &temp2;
43362 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43363 }
43364 {
43365 PyThreadState* __tstate = wxPyBeginAllowThreads();
43366 (arg1)->SetTextColour((wxColour const &)*arg2);
43367 wxPyEndAllowThreads(__tstate);
43368 if (PyErr_Occurred()) SWIG_fail;
43369 }
43370 resultobj = SWIG_Py_Void();
43371 return resultobj;
43372 fail:
43373 return NULL;
43374 }
43375
43376
43377 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43378 PyObject *resultobj = 0;
43379 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43380 wxColour result;
43381 void *argp1 = 0 ;
43382 int res1 = 0 ;
43383 PyObject *swig_obj[1] ;
43384
43385 if (!args) SWIG_fail;
43386 swig_obj[0] = args;
43387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43388 if (!SWIG_IsOK(res1)) {
43389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43390 }
43391 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43392 {
43393 PyThreadState* __tstate = wxPyBeginAllowThreads();
43394 result = (arg1)->GetTextColour();
43395 wxPyEndAllowThreads(__tstate);
43396 if (PyErr_Occurred()) SWIG_fail;
43397 }
43398 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43399 return resultobj;
43400 fail:
43401 return NULL;
43402 }
43403
43404
43405 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43406 PyObject *resultobj = 0;
43407 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43408 wxColour *arg2 = 0 ;
43409 void *argp1 = 0 ;
43410 int res1 = 0 ;
43411 wxColour temp2 ;
43412 PyObject * obj0 = 0 ;
43413 PyObject * obj1 = 0 ;
43414 char * kwnames[] = {
43415 (char *) "self",(char *) "colBack", NULL
43416 };
43417
43418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43420 if (!SWIG_IsOK(res1)) {
43421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43422 }
43423 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43424 {
43425 arg2 = &temp2;
43426 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43427 }
43428 {
43429 PyThreadState* __tstate = wxPyBeginAllowThreads();
43430 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43431 wxPyEndAllowThreads(__tstate);
43432 if (PyErr_Occurred()) SWIG_fail;
43433 }
43434 resultobj = SWIG_Py_Void();
43435 return resultobj;
43436 fail:
43437 return NULL;
43438 }
43439
43440
43441 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43442 PyObject *resultobj = 0;
43443 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43444 wxColour result;
43445 void *argp1 = 0 ;
43446 int res1 = 0 ;
43447 PyObject *swig_obj[1] ;
43448
43449 if (!args) SWIG_fail;
43450 swig_obj[0] = args;
43451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43452 if (!SWIG_IsOK(res1)) {
43453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43454 }
43455 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43456 {
43457 PyThreadState* __tstate = wxPyBeginAllowThreads();
43458 result = (arg1)->GetBackgroundColour();
43459 wxPyEndAllowThreads(__tstate);
43460 if (PyErr_Occurred()) SWIG_fail;
43461 }
43462 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43463 return resultobj;
43464 fail:
43465 return NULL;
43466 }
43467
43468
43469 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43470 PyObject *resultobj = 0;
43471 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43472 wxBitmap *arg2 = 0 ;
43473 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43474 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43475 void *argp1 = 0 ;
43476 int res1 = 0 ;
43477 void *argp2 = 0 ;
43478 int res2 = 0 ;
43479 void *argp3 = 0 ;
43480 int res3 = 0 ;
43481 PyObject * obj0 = 0 ;
43482 PyObject * obj1 = 0 ;
43483 PyObject * obj2 = 0 ;
43484 char * kwnames[] = {
43485 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43486 };
43487
43488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43490 if (!SWIG_IsOK(res1)) {
43491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43492 }
43493 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43494 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43495 if (!SWIG_IsOK(res2)) {
43496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43497 }
43498 if (!argp2) {
43499 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43500 }
43501 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43502 if (obj2) {
43503 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43504 if (!SWIG_IsOK(res3)) {
43505 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43506 }
43507 if (!argp3) {
43508 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43509 }
43510 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43511 }
43512 {
43513 PyThreadState* __tstate = wxPyBeginAllowThreads();
43514 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43515 wxPyEndAllowThreads(__tstate);
43516 if (PyErr_Occurred()) SWIG_fail;
43517 }
43518 resultobj = SWIG_Py_Void();
43519 return resultobj;
43520 fail:
43521 return NULL;
43522 }
43523
43524
43525 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43526 PyObject *resultobj = 0;
43527 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43528 wxBitmap *arg2 = 0 ;
43529 void *argp1 = 0 ;
43530 int res1 = 0 ;
43531 void *argp2 = 0 ;
43532 int res2 = 0 ;
43533 PyObject * obj0 = 0 ;
43534 PyObject * obj1 = 0 ;
43535 char * kwnames[] = {
43536 (char *) "self",(char *) "bmpDisabled", NULL
43537 };
43538
43539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43541 if (!SWIG_IsOK(res1)) {
43542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43543 }
43544 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43545 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43546 if (!SWIG_IsOK(res2)) {
43547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43548 }
43549 if (!argp2) {
43550 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43551 }
43552 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43553 {
43554 PyThreadState* __tstate = wxPyBeginAllowThreads();
43555 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43556 wxPyEndAllowThreads(__tstate);
43557 if (PyErr_Occurred()) SWIG_fail;
43558 }
43559 resultobj = SWIG_Py_Void();
43560 return resultobj;
43561 fail:
43562 return NULL;
43563 }
43564
43565
43566 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43567 PyObject *resultobj = 0;
43568 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43569 wxBitmap *result = 0 ;
43570 void *argp1 = 0 ;
43571 int res1 = 0 ;
43572 PyObject *swig_obj[1] ;
43573
43574 if (!args) SWIG_fail;
43575 swig_obj[0] = args;
43576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43577 if (!SWIG_IsOK(res1)) {
43578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43579 }
43580 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43581 {
43582 PyThreadState* __tstate = wxPyBeginAllowThreads();
43583 {
43584 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43585 result = (wxBitmap *) &_result_ref;
43586 }
43587 wxPyEndAllowThreads(__tstate);
43588 if (PyErr_Occurred()) SWIG_fail;
43589 }
43590 {
43591 wxBitmap* resultptr = new wxBitmap(*result);
43592 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43593 }
43594 return resultobj;
43595 fail:
43596 return NULL;
43597 }
43598
43599
43600 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43601 PyObject *resultobj = 0;
43602 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43603 int arg2 ;
43604 void *argp1 = 0 ;
43605 int res1 = 0 ;
43606 int val2 ;
43607 int ecode2 = 0 ;
43608 PyObject * obj0 = 0 ;
43609 PyObject * obj1 = 0 ;
43610 char * kwnames[] = {
43611 (char *) "self",(char *) "nWidth", NULL
43612 };
43613
43614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43616 if (!SWIG_IsOK(res1)) {
43617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43618 }
43619 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43620 ecode2 = SWIG_AsVal_int(obj1, &val2);
43621 if (!SWIG_IsOK(ecode2)) {
43622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43623 }
43624 arg2 = static_cast< int >(val2);
43625 {
43626 PyThreadState* __tstate = wxPyBeginAllowThreads();
43627 (arg1)->SetMarginWidth(arg2);
43628 wxPyEndAllowThreads(__tstate);
43629 if (PyErr_Occurred()) SWIG_fail;
43630 }
43631 resultobj = SWIG_Py_Void();
43632 return resultobj;
43633 fail:
43634 return NULL;
43635 }
43636
43637
43638 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43639 PyObject *resultobj = 0;
43640 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43641 int result;
43642 void *argp1 = 0 ;
43643 int res1 = 0 ;
43644 PyObject *swig_obj[1] ;
43645
43646 if (!args) SWIG_fail;
43647 swig_obj[0] = args;
43648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43649 if (!SWIG_IsOK(res1)) {
43650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43651 }
43652 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43653 {
43654 PyThreadState* __tstate = wxPyBeginAllowThreads();
43655 result = (int)(arg1)->GetMarginWidth();
43656 wxPyEndAllowThreads(__tstate);
43657 if (PyErr_Occurred()) SWIG_fail;
43658 }
43659 resultobj = SWIG_From_int(static_cast< int >(result));
43660 return resultobj;
43661 fail:
43662 return NULL;
43663 }
43664
43665
43666 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43667 PyObject *resultobj = 0;
43668 int result;
43669
43670 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43671 {
43672 PyThreadState* __tstate = wxPyBeginAllowThreads();
43673 result = (int)wxMenuItem::GetDefaultMarginWidth();
43674 wxPyEndAllowThreads(__tstate);
43675 if (PyErr_Occurred()) SWIG_fail;
43676 }
43677 resultobj = SWIG_From_int(static_cast< int >(result));
43678 return resultobj;
43679 fail:
43680 return NULL;
43681 }
43682
43683
43684 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43685 PyObject *resultobj = 0;
43686 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43687 bool result;
43688 void *argp1 = 0 ;
43689 int res1 = 0 ;
43690 PyObject *swig_obj[1] ;
43691
43692 if (!args) SWIG_fail;
43693 swig_obj[0] = args;
43694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43695 if (!SWIG_IsOK(res1)) {
43696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43697 }
43698 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43699 {
43700 PyThreadState* __tstate = wxPyBeginAllowThreads();
43701 result = (bool)(arg1)->IsOwnerDrawn();
43702 wxPyEndAllowThreads(__tstate);
43703 if (PyErr_Occurred()) SWIG_fail;
43704 }
43705 {
43706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43707 }
43708 return resultobj;
43709 fail:
43710 return NULL;
43711 }
43712
43713
43714 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43715 PyObject *resultobj = 0;
43716 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43717 bool arg2 = (bool) true ;
43718 void *argp1 = 0 ;
43719 int res1 = 0 ;
43720 bool val2 ;
43721 int ecode2 = 0 ;
43722 PyObject * obj0 = 0 ;
43723 PyObject * obj1 = 0 ;
43724 char * kwnames[] = {
43725 (char *) "self",(char *) "ownerDrawn", NULL
43726 };
43727
43728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43730 if (!SWIG_IsOK(res1)) {
43731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43732 }
43733 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43734 if (obj1) {
43735 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43736 if (!SWIG_IsOK(ecode2)) {
43737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43738 }
43739 arg2 = static_cast< bool >(val2);
43740 }
43741 {
43742 PyThreadState* __tstate = wxPyBeginAllowThreads();
43743 (arg1)->SetOwnerDrawn(arg2);
43744 wxPyEndAllowThreads(__tstate);
43745 if (PyErr_Occurred()) SWIG_fail;
43746 }
43747 resultobj = SWIG_Py_Void();
43748 return resultobj;
43749 fail:
43750 return NULL;
43751 }
43752
43753
43754 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43755 PyObject *resultobj = 0;
43756 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43757 void *argp1 = 0 ;
43758 int res1 = 0 ;
43759 PyObject *swig_obj[1] ;
43760
43761 if (!args) SWIG_fail;
43762 swig_obj[0] = args;
43763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43764 if (!SWIG_IsOK(res1)) {
43765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43766 }
43767 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43768 {
43769 PyThreadState* __tstate = wxPyBeginAllowThreads();
43770 (arg1)->ResetOwnerDrawn();
43771 wxPyEndAllowThreads(__tstate);
43772 if (PyErr_Occurred()) SWIG_fail;
43773 }
43774 resultobj = SWIG_Py_Void();
43775 return resultobj;
43776 fail:
43777 return NULL;
43778 }
43779
43780
43781 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43782 PyObject *obj;
43783 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43784 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43785 return SWIG_Py_Void();
43786 }
43787
43788 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43789 return SWIG_Python_InitShadowInstance(args);
43790 }
43791
43792 SWIGINTERN int ControlNameStr_set(PyObject *) {
43793 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43794 return 1;
43795 }
43796
43797
43798 SWIGINTERN PyObject *ControlNameStr_get(void) {
43799 PyObject *pyobj = 0;
43800
43801 {
43802 #if wxUSE_UNICODE
43803 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43804 #else
43805 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43806 #endif
43807 }
43808 return pyobj;
43809 }
43810
43811
43812 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43813 PyObject *resultobj = 0;
43814 wxWindow *arg1 = (wxWindow *) 0 ;
43815 int arg2 = (int) -1 ;
43816 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43817 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43818 wxSize const &arg4_defvalue = wxDefaultSize ;
43819 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43820 long arg5 = (long) 0 ;
43821 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43822 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43823 wxString const &arg7_defvalue = wxPyControlNameStr ;
43824 wxString *arg7 = (wxString *) &arg7_defvalue ;
43825 wxControl *result = 0 ;
43826 void *argp1 = 0 ;
43827 int res1 = 0 ;
43828 int val2 ;
43829 int ecode2 = 0 ;
43830 wxPoint temp3 ;
43831 wxSize temp4 ;
43832 long val5 ;
43833 int ecode5 = 0 ;
43834 void *argp6 = 0 ;
43835 int res6 = 0 ;
43836 bool temp7 = false ;
43837 PyObject * obj0 = 0 ;
43838 PyObject * obj1 = 0 ;
43839 PyObject * obj2 = 0 ;
43840 PyObject * obj3 = 0 ;
43841 PyObject * obj4 = 0 ;
43842 PyObject * obj5 = 0 ;
43843 PyObject * obj6 = 0 ;
43844 char * kwnames[] = {
43845 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43846 };
43847
43848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43850 if (!SWIG_IsOK(res1)) {
43851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43852 }
43853 arg1 = reinterpret_cast< wxWindow * >(argp1);
43854 if (obj1) {
43855 ecode2 = SWIG_AsVal_int(obj1, &val2);
43856 if (!SWIG_IsOK(ecode2)) {
43857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43858 }
43859 arg2 = static_cast< int >(val2);
43860 }
43861 if (obj2) {
43862 {
43863 arg3 = &temp3;
43864 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43865 }
43866 }
43867 if (obj3) {
43868 {
43869 arg4 = &temp4;
43870 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43871 }
43872 }
43873 if (obj4) {
43874 ecode5 = SWIG_AsVal_long(obj4, &val5);
43875 if (!SWIG_IsOK(ecode5)) {
43876 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43877 }
43878 arg5 = static_cast< long >(val5);
43879 }
43880 if (obj5) {
43881 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43882 if (!SWIG_IsOK(res6)) {
43883 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43884 }
43885 if (!argp6) {
43886 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43887 }
43888 arg6 = reinterpret_cast< wxValidator * >(argp6);
43889 }
43890 if (obj6) {
43891 {
43892 arg7 = wxString_in_helper(obj6);
43893 if (arg7 == NULL) SWIG_fail;
43894 temp7 = true;
43895 }
43896 }
43897 {
43898 if (!wxPyCheckForApp()) SWIG_fail;
43899 PyThreadState* __tstate = wxPyBeginAllowThreads();
43900 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43901 wxPyEndAllowThreads(__tstate);
43902 if (PyErr_Occurred()) SWIG_fail;
43903 }
43904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43905 {
43906 if (temp7)
43907 delete arg7;
43908 }
43909 return resultobj;
43910 fail:
43911 {
43912 if (temp7)
43913 delete arg7;
43914 }
43915 return NULL;
43916 }
43917
43918
43919 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43920 PyObject *resultobj = 0;
43921 wxControl *result = 0 ;
43922
43923 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43924 {
43925 if (!wxPyCheckForApp()) SWIG_fail;
43926 PyThreadState* __tstate = wxPyBeginAllowThreads();
43927 result = (wxControl *)new wxControl();
43928 wxPyEndAllowThreads(__tstate);
43929 if (PyErr_Occurred()) SWIG_fail;
43930 }
43931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43932 return resultobj;
43933 fail:
43934 return NULL;
43935 }
43936
43937
43938 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43939 PyObject *resultobj = 0;
43940 wxControl *arg1 = (wxControl *) 0 ;
43941 wxWindow *arg2 = (wxWindow *) 0 ;
43942 int arg3 = (int) -1 ;
43943 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43944 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43945 wxSize const &arg5_defvalue = wxDefaultSize ;
43946 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43947 long arg6 = (long) 0 ;
43948 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43949 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43950 wxString const &arg8_defvalue = wxPyControlNameStr ;
43951 wxString *arg8 = (wxString *) &arg8_defvalue ;
43952 bool result;
43953 void *argp1 = 0 ;
43954 int res1 = 0 ;
43955 void *argp2 = 0 ;
43956 int res2 = 0 ;
43957 int val3 ;
43958 int ecode3 = 0 ;
43959 wxPoint temp4 ;
43960 wxSize temp5 ;
43961 long val6 ;
43962 int ecode6 = 0 ;
43963 void *argp7 = 0 ;
43964 int res7 = 0 ;
43965 bool temp8 = false ;
43966 PyObject * obj0 = 0 ;
43967 PyObject * obj1 = 0 ;
43968 PyObject * obj2 = 0 ;
43969 PyObject * obj3 = 0 ;
43970 PyObject * obj4 = 0 ;
43971 PyObject * obj5 = 0 ;
43972 PyObject * obj6 = 0 ;
43973 PyObject * obj7 = 0 ;
43974 char * kwnames[] = {
43975 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43976 };
43977
43978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43980 if (!SWIG_IsOK(res1)) {
43981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43982 }
43983 arg1 = reinterpret_cast< wxControl * >(argp1);
43984 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43985 if (!SWIG_IsOK(res2)) {
43986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43987 }
43988 arg2 = reinterpret_cast< wxWindow * >(argp2);
43989 if (obj2) {
43990 ecode3 = SWIG_AsVal_int(obj2, &val3);
43991 if (!SWIG_IsOK(ecode3)) {
43992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43993 }
43994 arg3 = static_cast< int >(val3);
43995 }
43996 if (obj3) {
43997 {
43998 arg4 = &temp4;
43999 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44000 }
44001 }
44002 if (obj4) {
44003 {
44004 arg5 = &temp5;
44005 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44006 }
44007 }
44008 if (obj5) {
44009 ecode6 = SWIG_AsVal_long(obj5, &val6);
44010 if (!SWIG_IsOK(ecode6)) {
44011 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44012 }
44013 arg6 = static_cast< long >(val6);
44014 }
44015 if (obj6) {
44016 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44017 if (!SWIG_IsOK(res7)) {
44018 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44019 }
44020 if (!argp7) {
44021 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44022 }
44023 arg7 = reinterpret_cast< wxValidator * >(argp7);
44024 }
44025 if (obj7) {
44026 {
44027 arg8 = wxString_in_helper(obj7);
44028 if (arg8 == NULL) SWIG_fail;
44029 temp8 = true;
44030 }
44031 }
44032 {
44033 PyThreadState* __tstate = wxPyBeginAllowThreads();
44034 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44035 wxPyEndAllowThreads(__tstate);
44036 if (PyErr_Occurred()) SWIG_fail;
44037 }
44038 {
44039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44040 }
44041 {
44042 if (temp8)
44043 delete arg8;
44044 }
44045 return resultobj;
44046 fail:
44047 {
44048 if (temp8)
44049 delete arg8;
44050 }
44051 return NULL;
44052 }
44053
44054
44055 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44056 PyObject *resultobj = 0;
44057 wxControl *arg1 = (wxControl *) 0 ;
44058 int result;
44059 void *argp1 = 0 ;
44060 int res1 = 0 ;
44061 PyObject *swig_obj[1] ;
44062
44063 if (!args) SWIG_fail;
44064 swig_obj[0] = args;
44065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44066 if (!SWIG_IsOK(res1)) {
44067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44068 }
44069 arg1 = reinterpret_cast< wxControl * >(argp1);
44070 {
44071 PyThreadState* __tstate = wxPyBeginAllowThreads();
44072 result = (int)((wxControl const *)arg1)->GetAlignment();
44073 wxPyEndAllowThreads(__tstate);
44074 if (PyErr_Occurred()) SWIG_fail;
44075 }
44076 resultobj = SWIG_From_int(static_cast< int >(result));
44077 return resultobj;
44078 fail:
44079 return NULL;
44080 }
44081
44082
44083 SWIGINTERN PyObject *_wrap_Control_GetLabelText__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
44084 PyObject *resultobj = 0;
44085 wxString *arg1 = 0 ;
44086 wxString result;
44087 bool temp1 = false ;
44088
44089 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
44090 {
44091 arg1 = wxString_in_helper(swig_obj[0]);
44092 if (arg1 == NULL) SWIG_fail;
44093 temp1 = true;
44094 }
44095 {
44096 PyThreadState* __tstate = wxPyBeginAllowThreads();
44097 result = wxControl::GetLabelText((wxString const &)*arg1);
44098 wxPyEndAllowThreads(__tstate);
44099 if (PyErr_Occurred()) SWIG_fail;
44100 }
44101 {
44102 #if wxUSE_UNICODE
44103 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44104 #else
44105 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44106 #endif
44107 }
44108 {
44109 if (temp1)
44110 delete arg1;
44111 }
44112 return resultobj;
44113 fail:
44114 {
44115 if (temp1)
44116 delete arg1;
44117 }
44118 return NULL;
44119 }
44120
44121
44122 SWIGINTERN PyObject *_wrap_Control_GetLabelText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
44123 PyObject *resultobj = 0;
44124 wxControl *arg1 = (wxControl *) 0 ;
44125 wxString result;
44126 void *argp1 = 0 ;
44127 int res1 = 0 ;
44128
44129 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
44130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44131 if (!SWIG_IsOK(res1)) {
44132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44133 }
44134 arg1 = reinterpret_cast< wxControl * >(argp1);
44135 {
44136 PyThreadState* __tstate = wxPyBeginAllowThreads();
44137 result = ((wxControl const *)arg1)->GetLabelText();
44138 wxPyEndAllowThreads(__tstate);
44139 if (PyErr_Occurred()) SWIG_fail;
44140 }
44141 {
44142 #if wxUSE_UNICODE
44143 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44144 #else
44145 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44146 #endif
44147 }
44148 return resultobj;
44149 fail:
44150 return NULL;
44151 }
44152
44153
44154 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *self, PyObject *args) {
44155 int argc;
44156 PyObject *argv[2];
44157
44158 if (!(argc = SWIG_Python_UnpackTuple(args,"Control_GetLabelText",0,1,argv))) SWIG_fail;
44159 --argc;
44160 if (argc == 1) {
44161 int _v = 0;
44162 {
44163 {
44164 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
44165 }
44166 }
44167 if (!_v) goto check_1;
44168 return _wrap_Control_GetLabelText__SWIG_0(self, argc, argv);
44169 }
44170 check_1:
44171
44172 if (argc == 1) {
44173 return _wrap_Control_GetLabelText__SWIG_1(self, argc, argv);
44174 }
44175
44176 fail:
44177 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Control_GetLabelText'");
44178 return NULL;
44179 }
44180
44181
44182 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44183 PyObject *resultobj = 0;
44184 wxControl *arg1 = (wxControl *) 0 ;
44185 wxCommandEvent *arg2 = 0 ;
44186 void *argp1 = 0 ;
44187 int res1 = 0 ;
44188 void *argp2 = 0 ;
44189 int res2 = 0 ;
44190 PyObject * obj0 = 0 ;
44191 PyObject * obj1 = 0 ;
44192 char * kwnames[] = {
44193 (char *) "self",(char *) "event", NULL
44194 };
44195
44196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44198 if (!SWIG_IsOK(res1)) {
44199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44200 }
44201 arg1 = reinterpret_cast< wxControl * >(argp1);
44202 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44203 if (!SWIG_IsOK(res2)) {
44204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44205 }
44206 if (!argp2) {
44207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44208 }
44209 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44210 {
44211 PyThreadState* __tstate = wxPyBeginAllowThreads();
44212 (arg1)->Command(*arg2);
44213 wxPyEndAllowThreads(__tstate);
44214 if (PyErr_Occurred()) SWIG_fail;
44215 }
44216 resultobj = SWIG_Py_Void();
44217 return resultobj;
44218 fail:
44219 return NULL;
44220 }
44221
44222
44223 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44224 PyObject *resultobj = 0;
44225 wxControl *arg1 = (wxControl *) 0 ;
44226 wxString result;
44227 void *argp1 = 0 ;
44228 int res1 = 0 ;
44229 PyObject *swig_obj[1] ;
44230
44231 if (!args) SWIG_fail;
44232 swig_obj[0] = args;
44233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44234 if (!SWIG_IsOK(res1)) {
44235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44236 }
44237 arg1 = reinterpret_cast< wxControl * >(argp1);
44238 {
44239 PyThreadState* __tstate = wxPyBeginAllowThreads();
44240 result = (arg1)->GetLabel();
44241 wxPyEndAllowThreads(__tstate);
44242 if (PyErr_Occurred()) SWIG_fail;
44243 }
44244 {
44245 #if wxUSE_UNICODE
44246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44247 #else
44248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44249 #endif
44250 }
44251 return resultobj;
44252 fail:
44253 return NULL;
44254 }
44255
44256
44257 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44258 PyObject *resultobj = 0;
44259 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44260 SwigValueWrapper<wxVisualAttributes > result;
44261 int val1 ;
44262 int ecode1 = 0 ;
44263 PyObject * obj0 = 0 ;
44264 char * kwnames[] = {
44265 (char *) "variant", NULL
44266 };
44267
44268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44269 if (obj0) {
44270 ecode1 = SWIG_AsVal_int(obj0, &val1);
44271 if (!SWIG_IsOK(ecode1)) {
44272 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44273 }
44274 arg1 = static_cast< wxWindowVariant >(val1);
44275 }
44276 {
44277 if (!wxPyCheckForApp()) SWIG_fail;
44278 PyThreadState* __tstate = wxPyBeginAllowThreads();
44279 result = wxControl::GetClassDefaultAttributes(arg1);
44280 wxPyEndAllowThreads(__tstate);
44281 if (PyErr_Occurred()) SWIG_fail;
44282 }
44283 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44284 return resultobj;
44285 fail:
44286 return NULL;
44287 }
44288
44289
44290 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44291 PyObject *obj;
44292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44293 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44294 return SWIG_Py_Void();
44295 }
44296
44297 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44298 return SWIG_Python_InitShadowInstance(args);
44299 }
44300
44301 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44302 PyObject *resultobj = 0;
44303 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44304 wxString *arg2 = 0 ;
44305 PyObject *arg3 = (PyObject *) NULL ;
44306 int result;
44307 void *argp1 = 0 ;
44308 int res1 = 0 ;
44309 bool temp2 = false ;
44310 PyObject * obj0 = 0 ;
44311 PyObject * obj1 = 0 ;
44312 PyObject * obj2 = 0 ;
44313 char * kwnames[] = {
44314 (char *) "self",(char *) "item",(char *) "clientData", NULL
44315 };
44316
44317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44319 if (!SWIG_IsOK(res1)) {
44320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44321 }
44322 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44323 {
44324 arg2 = wxString_in_helper(obj1);
44325 if (arg2 == NULL) SWIG_fail;
44326 temp2 = true;
44327 }
44328 if (obj2) {
44329 arg3 = obj2;
44330 }
44331 {
44332 PyThreadState* __tstate = wxPyBeginAllowThreads();
44333 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44334 wxPyEndAllowThreads(__tstate);
44335 if (PyErr_Occurred()) SWIG_fail;
44336 }
44337 resultobj = SWIG_From_int(static_cast< int >(result));
44338 {
44339 if (temp2)
44340 delete arg2;
44341 }
44342 return resultobj;
44343 fail:
44344 {
44345 if (temp2)
44346 delete arg2;
44347 }
44348 return NULL;
44349 }
44350
44351
44352 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44353 PyObject *resultobj = 0;
44354 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44355 wxArrayString *arg2 = 0 ;
44356 void *argp1 = 0 ;
44357 int res1 = 0 ;
44358 bool temp2 = false ;
44359 PyObject * obj0 = 0 ;
44360 PyObject * obj1 = 0 ;
44361 char * kwnames[] = {
44362 (char *) "self",(char *) "strings", NULL
44363 };
44364
44365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44367 if (!SWIG_IsOK(res1)) {
44368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44369 }
44370 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44371 {
44372 if (! PySequence_Check(obj1)) {
44373 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44374 SWIG_fail;
44375 }
44376 arg2 = new wxArrayString;
44377 temp2 = true;
44378 int i, len=PySequence_Length(obj1);
44379 for (i=0; i<len; i++) {
44380 PyObject* item = PySequence_GetItem(obj1, i);
44381 wxString* s = wxString_in_helper(item);
44382 if (PyErr_Occurred()) SWIG_fail;
44383 arg2->Add(*s);
44384 delete s;
44385 Py_DECREF(item);
44386 }
44387 }
44388 {
44389 PyThreadState* __tstate = wxPyBeginAllowThreads();
44390 (arg1)->Append((wxArrayString const &)*arg2);
44391 wxPyEndAllowThreads(__tstate);
44392 if (PyErr_Occurred()) SWIG_fail;
44393 }
44394 resultobj = SWIG_Py_Void();
44395 {
44396 if (temp2) delete arg2;
44397 }
44398 return resultobj;
44399 fail:
44400 {
44401 if (temp2) delete arg2;
44402 }
44403 return NULL;
44404 }
44405
44406
44407 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44408 PyObject *resultobj = 0;
44409 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44410 wxString *arg2 = 0 ;
44411 unsigned int arg3 ;
44412 PyObject *arg4 = (PyObject *) NULL ;
44413 int result;
44414 void *argp1 = 0 ;
44415 int res1 = 0 ;
44416 bool temp2 = false ;
44417 unsigned int val3 ;
44418 int ecode3 = 0 ;
44419 PyObject * obj0 = 0 ;
44420 PyObject * obj1 = 0 ;
44421 PyObject * obj2 = 0 ;
44422 PyObject * obj3 = 0 ;
44423 char * kwnames[] = {
44424 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44425 };
44426
44427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44429 if (!SWIG_IsOK(res1)) {
44430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44431 }
44432 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44433 {
44434 arg2 = wxString_in_helper(obj1);
44435 if (arg2 == NULL) SWIG_fail;
44436 temp2 = true;
44437 }
44438 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44439 if (!SWIG_IsOK(ecode3)) {
44440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44441 }
44442 arg3 = static_cast< unsigned int >(val3);
44443 if (obj3) {
44444 arg4 = obj3;
44445 }
44446 {
44447 PyThreadState* __tstate = wxPyBeginAllowThreads();
44448 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44449 wxPyEndAllowThreads(__tstate);
44450 if (PyErr_Occurred()) SWIG_fail;
44451 }
44452 resultobj = SWIG_From_int(static_cast< int >(result));
44453 {
44454 if (temp2)
44455 delete arg2;
44456 }
44457 return resultobj;
44458 fail:
44459 {
44460 if (temp2)
44461 delete arg2;
44462 }
44463 return NULL;
44464 }
44465
44466
44467 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44468 PyObject *resultobj = 0;
44469 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44470 void *argp1 = 0 ;
44471 int res1 = 0 ;
44472 PyObject *swig_obj[1] ;
44473
44474 if (!args) SWIG_fail;
44475 swig_obj[0] = args;
44476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44477 if (!SWIG_IsOK(res1)) {
44478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44479 }
44480 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44481 {
44482 PyThreadState* __tstate = wxPyBeginAllowThreads();
44483 (arg1)->Clear();
44484 wxPyEndAllowThreads(__tstate);
44485 if (PyErr_Occurred()) SWIG_fail;
44486 }
44487 resultobj = SWIG_Py_Void();
44488 return resultobj;
44489 fail:
44490 return NULL;
44491 }
44492
44493
44494 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44495 PyObject *resultobj = 0;
44496 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44497 unsigned int arg2 ;
44498 void *argp1 = 0 ;
44499 int res1 = 0 ;
44500 unsigned int val2 ;
44501 int ecode2 = 0 ;
44502 PyObject * obj0 = 0 ;
44503 PyObject * obj1 = 0 ;
44504 char * kwnames[] = {
44505 (char *) "self",(char *) "n", NULL
44506 };
44507
44508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44510 if (!SWIG_IsOK(res1)) {
44511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44512 }
44513 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44514 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44515 if (!SWIG_IsOK(ecode2)) {
44516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44517 }
44518 arg2 = static_cast< unsigned int >(val2);
44519 {
44520 PyThreadState* __tstate = wxPyBeginAllowThreads();
44521 (arg1)->Delete(arg2);
44522 wxPyEndAllowThreads(__tstate);
44523 if (PyErr_Occurred()) SWIG_fail;
44524 }
44525 resultobj = SWIG_Py_Void();
44526 return resultobj;
44527 fail:
44528 return NULL;
44529 }
44530
44531
44532 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44533 PyObject *resultobj = 0;
44534 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44535 unsigned int arg2 ;
44536 PyObject *result = 0 ;
44537 void *argp1 = 0 ;
44538 int res1 = 0 ;
44539 unsigned int val2 ;
44540 int ecode2 = 0 ;
44541 PyObject * obj0 = 0 ;
44542 PyObject * obj1 = 0 ;
44543 char * kwnames[] = {
44544 (char *) "self",(char *) "n", NULL
44545 };
44546
44547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44549 if (!SWIG_IsOK(res1)) {
44550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44551 }
44552 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44553 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44554 if (!SWIG_IsOK(ecode2)) {
44555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44556 }
44557 arg2 = static_cast< unsigned int >(val2);
44558 {
44559 PyThreadState* __tstate = wxPyBeginAllowThreads();
44560 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44561 wxPyEndAllowThreads(__tstate);
44562 if (PyErr_Occurred()) SWIG_fail;
44563 }
44564 resultobj = result;
44565 return resultobj;
44566 fail:
44567 return NULL;
44568 }
44569
44570
44571 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44572 PyObject *resultobj = 0;
44573 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44574 unsigned int arg2 ;
44575 PyObject *arg3 = (PyObject *) 0 ;
44576 void *argp1 = 0 ;
44577 int res1 = 0 ;
44578 unsigned int val2 ;
44579 int ecode2 = 0 ;
44580 PyObject * obj0 = 0 ;
44581 PyObject * obj1 = 0 ;
44582 PyObject * obj2 = 0 ;
44583 char * kwnames[] = {
44584 (char *) "self",(char *) "n",(char *) "clientData", NULL
44585 };
44586
44587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44589 if (!SWIG_IsOK(res1)) {
44590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44591 }
44592 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44593 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44594 if (!SWIG_IsOK(ecode2)) {
44595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44596 }
44597 arg2 = static_cast< unsigned int >(val2);
44598 arg3 = obj2;
44599 {
44600 PyThreadState* __tstate = wxPyBeginAllowThreads();
44601 wxItemContainer_SetClientData(arg1,arg2,arg3);
44602 wxPyEndAllowThreads(__tstate);
44603 if (PyErr_Occurred()) SWIG_fail;
44604 }
44605 resultobj = SWIG_Py_Void();
44606 return resultobj;
44607 fail:
44608 return NULL;
44609 }
44610
44611
44612 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44613 PyObject *resultobj = 0;
44614 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44615 unsigned int result;
44616 void *argp1 = 0 ;
44617 int res1 = 0 ;
44618 PyObject *swig_obj[1] ;
44619
44620 if (!args) SWIG_fail;
44621 swig_obj[0] = args;
44622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44623 if (!SWIG_IsOK(res1)) {
44624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44625 }
44626 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44627 {
44628 PyThreadState* __tstate = wxPyBeginAllowThreads();
44629 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44630 wxPyEndAllowThreads(__tstate);
44631 if (PyErr_Occurred()) SWIG_fail;
44632 }
44633 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44634 return resultobj;
44635 fail:
44636 return NULL;
44637 }
44638
44639
44640 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44641 PyObject *resultobj = 0;
44642 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44643 bool result;
44644 void *argp1 = 0 ;
44645 int res1 = 0 ;
44646 PyObject *swig_obj[1] ;
44647
44648 if (!args) SWIG_fail;
44649 swig_obj[0] = args;
44650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44651 if (!SWIG_IsOK(res1)) {
44652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44653 }
44654 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44655 {
44656 PyThreadState* __tstate = wxPyBeginAllowThreads();
44657 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44658 wxPyEndAllowThreads(__tstate);
44659 if (PyErr_Occurred()) SWIG_fail;
44660 }
44661 {
44662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44663 }
44664 return resultobj;
44665 fail:
44666 return NULL;
44667 }
44668
44669
44670 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44671 PyObject *resultobj = 0;
44672 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44673 unsigned int arg2 ;
44674 wxString result;
44675 void *argp1 = 0 ;
44676 int res1 = 0 ;
44677 unsigned int val2 ;
44678 int ecode2 = 0 ;
44679 PyObject * obj0 = 0 ;
44680 PyObject * obj1 = 0 ;
44681 char * kwnames[] = {
44682 (char *) "self",(char *) "n", NULL
44683 };
44684
44685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44687 if (!SWIG_IsOK(res1)) {
44688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44689 }
44690 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44691 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44692 if (!SWIG_IsOK(ecode2)) {
44693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44694 }
44695 arg2 = static_cast< unsigned int >(val2);
44696 {
44697 PyThreadState* __tstate = wxPyBeginAllowThreads();
44698 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44699 wxPyEndAllowThreads(__tstate);
44700 if (PyErr_Occurred()) SWIG_fail;
44701 }
44702 {
44703 #if wxUSE_UNICODE
44704 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44705 #else
44706 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44707 #endif
44708 }
44709 return resultobj;
44710 fail:
44711 return NULL;
44712 }
44713
44714
44715 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44716 PyObject *resultobj = 0;
44717 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44718 wxArrayString result;
44719 void *argp1 = 0 ;
44720 int res1 = 0 ;
44721 PyObject *swig_obj[1] ;
44722
44723 if (!args) SWIG_fail;
44724 swig_obj[0] = args;
44725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44726 if (!SWIG_IsOK(res1)) {
44727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44728 }
44729 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44730 {
44731 PyThreadState* __tstate = wxPyBeginAllowThreads();
44732 result = ((wxItemContainer const *)arg1)->GetStrings();
44733 wxPyEndAllowThreads(__tstate);
44734 if (PyErr_Occurred()) SWIG_fail;
44735 }
44736 {
44737 resultobj = wxArrayString2PyList_helper(result);
44738 }
44739 return resultobj;
44740 fail:
44741 return NULL;
44742 }
44743
44744
44745 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44746 PyObject *resultobj = 0;
44747 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44748 unsigned int arg2 ;
44749 wxString *arg3 = 0 ;
44750 void *argp1 = 0 ;
44751 int res1 = 0 ;
44752 unsigned int val2 ;
44753 int ecode2 = 0 ;
44754 bool temp3 = false ;
44755 PyObject * obj0 = 0 ;
44756 PyObject * obj1 = 0 ;
44757 PyObject * obj2 = 0 ;
44758 char * kwnames[] = {
44759 (char *) "self",(char *) "n",(char *) "s", NULL
44760 };
44761
44762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44764 if (!SWIG_IsOK(res1)) {
44765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44766 }
44767 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44768 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44769 if (!SWIG_IsOK(ecode2)) {
44770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44771 }
44772 arg2 = static_cast< unsigned int >(val2);
44773 {
44774 arg3 = wxString_in_helper(obj2);
44775 if (arg3 == NULL) SWIG_fail;
44776 temp3 = true;
44777 }
44778 {
44779 PyThreadState* __tstate = wxPyBeginAllowThreads();
44780 (arg1)->SetString(arg2,(wxString const &)*arg3);
44781 wxPyEndAllowThreads(__tstate);
44782 if (PyErr_Occurred()) SWIG_fail;
44783 }
44784 resultobj = SWIG_Py_Void();
44785 {
44786 if (temp3)
44787 delete arg3;
44788 }
44789 return resultobj;
44790 fail:
44791 {
44792 if (temp3)
44793 delete arg3;
44794 }
44795 return NULL;
44796 }
44797
44798
44799 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44800 PyObject *resultobj = 0;
44801 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44802 wxString *arg2 = 0 ;
44803 int result;
44804 void *argp1 = 0 ;
44805 int res1 = 0 ;
44806 bool temp2 = false ;
44807 PyObject * obj0 = 0 ;
44808 PyObject * obj1 = 0 ;
44809 char * kwnames[] = {
44810 (char *) "self",(char *) "s", NULL
44811 };
44812
44813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44815 if (!SWIG_IsOK(res1)) {
44816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44817 }
44818 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44819 {
44820 arg2 = wxString_in_helper(obj1);
44821 if (arg2 == NULL) SWIG_fail;
44822 temp2 = true;
44823 }
44824 {
44825 PyThreadState* __tstate = wxPyBeginAllowThreads();
44826 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44827 wxPyEndAllowThreads(__tstate);
44828 if (PyErr_Occurred()) SWIG_fail;
44829 }
44830 resultobj = SWIG_From_int(static_cast< int >(result));
44831 {
44832 if (temp2)
44833 delete arg2;
44834 }
44835 return resultobj;
44836 fail:
44837 {
44838 if (temp2)
44839 delete arg2;
44840 }
44841 return NULL;
44842 }
44843
44844
44845 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44846 PyObject *resultobj = 0;
44847 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44848 int arg2 ;
44849 void *argp1 = 0 ;
44850 int res1 = 0 ;
44851 int val2 ;
44852 int ecode2 = 0 ;
44853 PyObject * obj0 = 0 ;
44854 PyObject * obj1 = 0 ;
44855 char * kwnames[] = {
44856 (char *) "self",(char *) "n", NULL
44857 };
44858
44859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44861 if (!SWIG_IsOK(res1)) {
44862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44863 }
44864 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44865 ecode2 = SWIG_AsVal_int(obj1, &val2);
44866 if (!SWIG_IsOK(ecode2)) {
44867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44868 }
44869 arg2 = static_cast< int >(val2);
44870 {
44871 PyThreadState* __tstate = wxPyBeginAllowThreads();
44872 (arg1)->SetSelection(arg2);
44873 wxPyEndAllowThreads(__tstate);
44874 if (PyErr_Occurred()) SWIG_fail;
44875 }
44876 resultobj = SWIG_Py_Void();
44877 return resultobj;
44878 fail:
44879 return NULL;
44880 }
44881
44882
44883 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44884 PyObject *resultobj = 0;
44885 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44886 int result;
44887 void *argp1 = 0 ;
44888 int res1 = 0 ;
44889 PyObject *swig_obj[1] ;
44890
44891 if (!args) SWIG_fail;
44892 swig_obj[0] = args;
44893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44894 if (!SWIG_IsOK(res1)) {
44895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44896 }
44897 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44898 {
44899 PyThreadState* __tstate = wxPyBeginAllowThreads();
44900 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44901 wxPyEndAllowThreads(__tstate);
44902 if (PyErr_Occurred()) SWIG_fail;
44903 }
44904 resultobj = SWIG_From_int(static_cast< int >(result));
44905 return resultobj;
44906 fail:
44907 return NULL;
44908 }
44909
44910
44911 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44912 PyObject *resultobj = 0;
44913 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44914 wxString *arg2 = 0 ;
44915 bool result;
44916 void *argp1 = 0 ;
44917 int res1 = 0 ;
44918 bool temp2 = false ;
44919 PyObject * obj0 = 0 ;
44920 PyObject * obj1 = 0 ;
44921 char * kwnames[] = {
44922 (char *) "self",(char *) "s", NULL
44923 };
44924
44925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44927 if (!SWIG_IsOK(res1)) {
44928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44929 }
44930 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44931 {
44932 arg2 = wxString_in_helper(obj1);
44933 if (arg2 == NULL) SWIG_fail;
44934 temp2 = true;
44935 }
44936 {
44937 PyThreadState* __tstate = wxPyBeginAllowThreads();
44938 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44939 wxPyEndAllowThreads(__tstate);
44940 if (PyErr_Occurred()) SWIG_fail;
44941 }
44942 {
44943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44944 }
44945 {
44946 if (temp2)
44947 delete arg2;
44948 }
44949 return resultobj;
44950 fail:
44951 {
44952 if (temp2)
44953 delete arg2;
44954 }
44955 return NULL;
44956 }
44957
44958
44959 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44960 PyObject *resultobj = 0;
44961 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44962 wxString result;
44963 void *argp1 = 0 ;
44964 int res1 = 0 ;
44965 PyObject *swig_obj[1] ;
44966
44967 if (!args) SWIG_fail;
44968 swig_obj[0] = args;
44969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44970 if (!SWIG_IsOK(res1)) {
44971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44972 }
44973 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44974 {
44975 PyThreadState* __tstate = wxPyBeginAllowThreads();
44976 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44977 wxPyEndAllowThreads(__tstate);
44978 if (PyErr_Occurred()) SWIG_fail;
44979 }
44980 {
44981 #if wxUSE_UNICODE
44982 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44983 #else
44984 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44985 #endif
44986 }
44987 return resultobj;
44988 fail:
44989 return NULL;
44990 }
44991
44992
44993 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44994 PyObject *resultobj = 0;
44995 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44996 int arg2 ;
44997 void *argp1 = 0 ;
44998 int res1 = 0 ;
44999 int val2 ;
45000 int ecode2 = 0 ;
45001 PyObject * obj0 = 0 ;
45002 PyObject * obj1 = 0 ;
45003 char * kwnames[] = {
45004 (char *) "self",(char *) "n", NULL
45005 };
45006
45007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45009 if (!SWIG_IsOK(res1)) {
45010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45011 }
45012 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45013 ecode2 = SWIG_AsVal_int(obj1, &val2);
45014 if (!SWIG_IsOK(ecode2)) {
45015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45016 }
45017 arg2 = static_cast< int >(val2);
45018 {
45019 PyThreadState* __tstate = wxPyBeginAllowThreads();
45020 (arg1)->Select(arg2);
45021 wxPyEndAllowThreads(__tstate);
45022 if (PyErr_Occurred()) SWIG_fail;
45023 }
45024 resultobj = SWIG_Py_Void();
45025 return resultobj;
45026 fail:
45027 return NULL;
45028 }
45029
45030
45031 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45032 PyObject *obj;
45033 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45034 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45035 return SWIG_Py_Void();
45036 }
45037
45038 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45039 PyObject *obj;
45040 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45041 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45042 return SWIG_Py_Void();
45043 }
45044
45045 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45046 PyObject *resultobj = 0;
45047 wxSizerItem *result = 0 ;
45048
45049 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45050 {
45051 PyThreadState* __tstate = wxPyBeginAllowThreads();
45052 result = (wxSizerItem *)new wxSizerItem();
45053 wxPyEndAllowThreads(__tstate);
45054 if (PyErr_Occurred()) SWIG_fail;
45055 }
45056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45057 return resultobj;
45058 fail:
45059 return NULL;
45060 }
45061
45062
45063 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45064 PyObject *resultobj = 0;
45065 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45066 void *argp1 = 0 ;
45067 int res1 = 0 ;
45068 PyObject *swig_obj[1] ;
45069
45070 if (!args) SWIG_fail;
45071 swig_obj[0] = args;
45072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45073 if (!SWIG_IsOK(res1)) {
45074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45075 }
45076 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45077 {
45078 PyThreadState* __tstate = wxPyBeginAllowThreads();
45079 delete arg1;
45080
45081 wxPyEndAllowThreads(__tstate);
45082 if (PyErr_Occurred()) SWIG_fail;
45083 }
45084 resultobj = SWIG_Py_Void();
45085 return resultobj;
45086 fail:
45087 return NULL;
45088 }
45089
45090
45091 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45092 PyObject *resultobj = 0;
45093 wxWindow *arg1 = (wxWindow *) 0 ;
45094 int arg2 ;
45095 int arg3 ;
45096 int arg4 ;
45097 PyObject *arg5 = (PyObject *) NULL ;
45098 wxSizerItem *result = 0 ;
45099 void *argp1 = 0 ;
45100 int res1 = 0 ;
45101 int val2 ;
45102 int ecode2 = 0 ;
45103 int val3 ;
45104 int ecode3 = 0 ;
45105 int val4 ;
45106 int ecode4 = 0 ;
45107 PyObject * obj0 = 0 ;
45108 PyObject * obj1 = 0 ;
45109 PyObject * obj2 = 0 ;
45110 PyObject * obj3 = 0 ;
45111 PyObject * obj4 = 0 ;
45112 char * kwnames[] = {
45113 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45114 };
45115
45116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45118 if (!SWIG_IsOK(res1)) {
45119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45120 }
45121 arg1 = reinterpret_cast< wxWindow * >(argp1);
45122 ecode2 = SWIG_AsVal_int(obj1, &val2);
45123 if (!SWIG_IsOK(ecode2)) {
45124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45125 }
45126 arg2 = static_cast< int >(val2);
45127 ecode3 = SWIG_AsVal_int(obj2, &val3);
45128 if (!SWIG_IsOK(ecode3)) {
45129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45130 }
45131 arg3 = static_cast< int >(val3);
45132 ecode4 = SWIG_AsVal_int(obj3, &val4);
45133 if (!SWIG_IsOK(ecode4)) {
45134 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45135 }
45136 arg4 = static_cast< int >(val4);
45137 if (obj4) {
45138 arg5 = obj4;
45139 }
45140 {
45141 PyThreadState* __tstate = wxPyBeginAllowThreads();
45142 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45143 wxPyEndAllowThreads(__tstate);
45144 if (PyErr_Occurred()) SWIG_fail;
45145 }
45146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45147 return resultobj;
45148 fail:
45149 return NULL;
45150 }
45151
45152
45153 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45154 PyObject *resultobj = 0;
45155 int arg1 ;
45156 int arg2 ;
45157 int arg3 ;
45158 int arg4 ;
45159 int arg5 ;
45160 PyObject *arg6 = (PyObject *) NULL ;
45161 wxSizerItem *result = 0 ;
45162 int val1 ;
45163 int ecode1 = 0 ;
45164 int val2 ;
45165 int ecode2 = 0 ;
45166 int val3 ;
45167 int ecode3 = 0 ;
45168 int val4 ;
45169 int ecode4 = 0 ;
45170 int val5 ;
45171 int ecode5 = 0 ;
45172 PyObject * obj0 = 0 ;
45173 PyObject * obj1 = 0 ;
45174 PyObject * obj2 = 0 ;
45175 PyObject * obj3 = 0 ;
45176 PyObject * obj4 = 0 ;
45177 PyObject * obj5 = 0 ;
45178 char * kwnames[] = {
45179 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45180 };
45181
45182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45183 ecode1 = SWIG_AsVal_int(obj0, &val1);
45184 if (!SWIG_IsOK(ecode1)) {
45185 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45186 }
45187 arg1 = static_cast< int >(val1);
45188 ecode2 = SWIG_AsVal_int(obj1, &val2);
45189 if (!SWIG_IsOK(ecode2)) {
45190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45191 }
45192 arg2 = static_cast< int >(val2);
45193 ecode3 = SWIG_AsVal_int(obj2, &val3);
45194 if (!SWIG_IsOK(ecode3)) {
45195 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45196 }
45197 arg3 = static_cast< int >(val3);
45198 ecode4 = SWIG_AsVal_int(obj3, &val4);
45199 if (!SWIG_IsOK(ecode4)) {
45200 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45201 }
45202 arg4 = static_cast< int >(val4);
45203 ecode5 = SWIG_AsVal_int(obj4, &val5);
45204 if (!SWIG_IsOK(ecode5)) {
45205 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45206 }
45207 arg5 = static_cast< int >(val5);
45208 if (obj5) {
45209 arg6 = obj5;
45210 }
45211 {
45212 PyThreadState* __tstate = wxPyBeginAllowThreads();
45213 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45214 wxPyEndAllowThreads(__tstate);
45215 if (PyErr_Occurred()) SWIG_fail;
45216 }
45217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45218 return resultobj;
45219 fail:
45220 return NULL;
45221 }
45222
45223
45224 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45225 PyObject *resultobj = 0;
45226 wxSizer *arg1 = (wxSizer *) 0 ;
45227 int arg2 ;
45228 int arg3 ;
45229 int arg4 ;
45230 PyObject *arg5 = (PyObject *) NULL ;
45231 wxSizerItem *result = 0 ;
45232 int res1 = 0 ;
45233 int val2 ;
45234 int ecode2 = 0 ;
45235 int val3 ;
45236 int ecode3 = 0 ;
45237 int val4 ;
45238 int ecode4 = 0 ;
45239 PyObject * obj0 = 0 ;
45240 PyObject * obj1 = 0 ;
45241 PyObject * obj2 = 0 ;
45242 PyObject * obj3 = 0 ;
45243 PyObject * obj4 = 0 ;
45244 char * kwnames[] = {
45245 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45246 };
45247
45248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45249 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45250 if (!SWIG_IsOK(res1)) {
45251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45252 }
45253 ecode2 = SWIG_AsVal_int(obj1, &val2);
45254 if (!SWIG_IsOK(ecode2)) {
45255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45256 }
45257 arg2 = static_cast< int >(val2);
45258 ecode3 = SWIG_AsVal_int(obj2, &val3);
45259 if (!SWIG_IsOK(ecode3)) {
45260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45261 }
45262 arg3 = static_cast< int >(val3);
45263 ecode4 = SWIG_AsVal_int(obj3, &val4);
45264 if (!SWIG_IsOK(ecode4)) {
45265 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45266 }
45267 arg4 = static_cast< int >(val4);
45268 if (obj4) {
45269 arg5 = obj4;
45270 }
45271 {
45272 PyThreadState* __tstate = wxPyBeginAllowThreads();
45273 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45274 wxPyEndAllowThreads(__tstate);
45275 if (PyErr_Occurred()) SWIG_fail;
45276 }
45277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45278 return resultobj;
45279 fail:
45280 return NULL;
45281 }
45282
45283
45284 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45285 PyObject *resultobj = 0;
45286 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45287 void *argp1 = 0 ;
45288 int res1 = 0 ;
45289 PyObject *swig_obj[1] ;
45290
45291 if (!args) SWIG_fail;
45292 swig_obj[0] = args;
45293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45294 if (!SWIG_IsOK(res1)) {
45295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45296 }
45297 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45298 {
45299 PyThreadState* __tstate = wxPyBeginAllowThreads();
45300 (arg1)->DeleteWindows();
45301 wxPyEndAllowThreads(__tstate);
45302 if (PyErr_Occurred()) SWIG_fail;
45303 }
45304 resultobj = SWIG_Py_Void();
45305 return resultobj;
45306 fail:
45307 return NULL;
45308 }
45309
45310
45311 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45312 PyObject *resultobj = 0;
45313 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45314 void *argp1 = 0 ;
45315 int res1 = 0 ;
45316 PyObject *swig_obj[1] ;
45317
45318 if (!args) SWIG_fail;
45319 swig_obj[0] = args;
45320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45321 if (!SWIG_IsOK(res1)) {
45322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45323 }
45324 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45325 {
45326 PyThreadState* __tstate = wxPyBeginAllowThreads();
45327 (arg1)->DetachSizer();
45328 wxPyEndAllowThreads(__tstate);
45329 if (PyErr_Occurred()) SWIG_fail;
45330 }
45331 resultobj = SWIG_Py_Void();
45332 return resultobj;
45333 fail:
45334 return NULL;
45335 }
45336
45337
45338 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45339 PyObject *resultobj = 0;
45340 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45341 wxSize result;
45342 void *argp1 = 0 ;
45343 int res1 = 0 ;
45344 PyObject *swig_obj[1] ;
45345
45346 if (!args) SWIG_fail;
45347 swig_obj[0] = args;
45348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45349 if (!SWIG_IsOK(res1)) {
45350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45351 }
45352 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45353 {
45354 PyThreadState* __tstate = wxPyBeginAllowThreads();
45355 result = (arg1)->GetSize();
45356 wxPyEndAllowThreads(__tstate);
45357 if (PyErr_Occurred()) SWIG_fail;
45358 }
45359 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45360 return resultobj;
45361 fail:
45362 return NULL;
45363 }
45364
45365
45366 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45367 PyObject *resultobj = 0;
45368 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45369 wxSize result;
45370 void *argp1 = 0 ;
45371 int res1 = 0 ;
45372 PyObject *swig_obj[1] ;
45373
45374 if (!args) SWIG_fail;
45375 swig_obj[0] = args;
45376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45377 if (!SWIG_IsOK(res1)) {
45378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45379 }
45380 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45381 {
45382 PyThreadState* __tstate = wxPyBeginAllowThreads();
45383 result = (arg1)->CalcMin();
45384 wxPyEndAllowThreads(__tstate);
45385 if (PyErr_Occurred()) SWIG_fail;
45386 }
45387 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45388 return resultobj;
45389 fail:
45390 return NULL;
45391 }
45392
45393
45394 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45395 PyObject *resultobj = 0;
45396 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45397 wxPoint *arg2 = 0 ;
45398 wxSize *arg3 = 0 ;
45399 void *argp1 = 0 ;
45400 int res1 = 0 ;
45401 wxPoint temp2 ;
45402 wxSize temp3 ;
45403 PyObject * obj0 = 0 ;
45404 PyObject * obj1 = 0 ;
45405 PyObject * obj2 = 0 ;
45406 char * kwnames[] = {
45407 (char *) "self",(char *) "pos",(char *) "size", NULL
45408 };
45409
45410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45412 if (!SWIG_IsOK(res1)) {
45413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45414 }
45415 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45416 {
45417 arg2 = &temp2;
45418 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45419 }
45420 {
45421 arg3 = &temp3;
45422 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45423 }
45424 {
45425 PyThreadState* __tstate = wxPyBeginAllowThreads();
45426 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45427 wxPyEndAllowThreads(__tstate);
45428 if (PyErr_Occurred()) SWIG_fail;
45429 }
45430 resultobj = SWIG_Py_Void();
45431 return resultobj;
45432 fail:
45433 return NULL;
45434 }
45435
45436
45437 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45438 PyObject *resultobj = 0;
45439 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45440 wxSize result;
45441 void *argp1 = 0 ;
45442 int res1 = 0 ;
45443 PyObject *swig_obj[1] ;
45444
45445 if (!args) SWIG_fail;
45446 swig_obj[0] = args;
45447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45448 if (!SWIG_IsOK(res1)) {
45449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45450 }
45451 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45452 {
45453 PyThreadState* __tstate = wxPyBeginAllowThreads();
45454 result = (arg1)->GetMinSize();
45455 wxPyEndAllowThreads(__tstate);
45456 if (PyErr_Occurred()) SWIG_fail;
45457 }
45458 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45459 return resultobj;
45460 fail:
45461 return NULL;
45462 }
45463
45464
45465 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45466 PyObject *resultobj = 0;
45467 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45468 wxSize result;
45469 void *argp1 = 0 ;
45470 int res1 = 0 ;
45471 PyObject *swig_obj[1] ;
45472
45473 if (!args) SWIG_fail;
45474 swig_obj[0] = args;
45475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45476 if (!SWIG_IsOK(res1)) {
45477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45478 }
45479 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45480 {
45481 PyThreadState* __tstate = wxPyBeginAllowThreads();
45482 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45483 wxPyEndAllowThreads(__tstate);
45484 if (PyErr_Occurred()) SWIG_fail;
45485 }
45486 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45487 return resultobj;
45488 fail:
45489 return NULL;
45490 }
45491
45492
45493 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45494 PyObject *resultobj = 0;
45495 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45496 int arg2 ;
45497 int arg3 ;
45498 void *argp1 = 0 ;
45499 int res1 = 0 ;
45500 int val2 ;
45501 int ecode2 = 0 ;
45502 int val3 ;
45503 int ecode3 = 0 ;
45504 PyObject * obj0 = 0 ;
45505 PyObject * obj1 = 0 ;
45506 PyObject * obj2 = 0 ;
45507 char * kwnames[] = {
45508 (char *) "self",(char *) "x",(char *) "y", NULL
45509 };
45510
45511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45513 if (!SWIG_IsOK(res1)) {
45514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45515 }
45516 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45517 ecode2 = SWIG_AsVal_int(obj1, &val2);
45518 if (!SWIG_IsOK(ecode2)) {
45519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45520 }
45521 arg2 = static_cast< int >(val2);
45522 ecode3 = SWIG_AsVal_int(obj2, &val3);
45523 if (!SWIG_IsOK(ecode3)) {
45524 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45525 }
45526 arg3 = static_cast< int >(val3);
45527 {
45528 PyThreadState* __tstate = wxPyBeginAllowThreads();
45529 (arg1)->SetInitSize(arg2,arg3);
45530 wxPyEndAllowThreads(__tstate);
45531 if (PyErr_Occurred()) SWIG_fail;
45532 }
45533 resultobj = SWIG_Py_Void();
45534 return resultobj;
45535 fail:
45536 return NULL;
45537 }
45538
45539
45540 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45541 PyObject *resultobj = 0;
45542 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45543 int arg2 ;
45544 int arg3 ;
45545 void *argp1 = 0 ;
45546 int res1 = 0 ;
45547 int val2 ;
45548 int ecode2 = 0 ;
45549 int val3 ;
45550 int ecode3 = 0 ;
45551 PyObject * obj0 = 0 ;
45552 PyObject * obj1 = 0 ;
45553 PyObject * obj2 = 0 ;
45554 char * kwnames[] = {
45555 (char *) "self",(char *) "width",(char *) "height", NULL
45556 };
45557
45558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45560 if (!SWIG_IsOK(res1)) {
45561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45562 }
45563 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45564 ecode2 = SWIG_AsVal_int(obj1, &val2);
45565 if (!SWIG_IsOK(ecode2)) {
45566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45567 }
45568 arg2 = static_cast< int >(val2);
45569 ecode3 = SWIG_AsVal_int(obj2, &val3);
45570 if (!SWIG_IsOK(ecode3)) {
45571 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45572 }
45573 arg3 = static_cast< int >(val3);
45574 {
45575 PyThreadState* __tstate = wxPyBeginAllowThreads();
45576 (arg1)->SetRatio(arg2,arg3);
45577 wxPyEndAllowThreads(__tstate);
45578 if (PyErr_Occurred()) SWIG_fail;
45579 }
45580 resultobj = SWIG_Py_Void();
45581 return resultobj;
45582 fail:
45583 return NULL;
45584 }
45585
45586
45587 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45588 PyObject *resultobj = 0;
45589 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45590 wxSize *arg2 = 0 ;
45591 void *argp1 = 0 ;
45592 int res1 = 0 ;
45593 wxSize temp2 ;
45594 PyObject * obj0 = 0 ;
45595 PyObject * obj1 = 0 ;
45596 char * kwnames[] = {
45597 (char *) "self",(char *) "size", NULL
45598 };
45599
45600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45602 if (!SWIG_IsOK(res1)) {
45603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45604 }
45605 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45606 {
45607 arg2 = &temp2;
45608 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45609 }
45610 {
45611 PyThreadState* __tstate = wxPyBeginAllowThreads();
45612 (arg1)->SetRatio((wxSize const &)*arg2);
45613 wxPyEndAllowThreads(__tstate);
45614 if (PyErr_Occurred()) SWIG_fail;
45615 }
45616 resultobj = SWIG_Py_Void();
45617 return resultobj;
45618 fail:
45619 return NULL;
45620 }
45621
45622
45623 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45624 PyObject *resultobj = 0;
45625 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45626 float arg2 ;
45627 void *argp1 = 0 ;
45628 int res1 = 0 ;
45629 float val2 ;
45630 int ecode2 = 0 ;
45631 PyObject * obj0 = 0 ;
45632 PyObject * obj1 = 0 ;
45633 char * kwnames[] = {
45634 (char *) "self",(char *) "ratio", NULL
45635 };
45636
45637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45639 if (!SWIG_IsOK(res1)) {
45640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45641 }
45642 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45643 ecode2 = SWIG_AsVal_float(obj1, &val2);
45644 if (!SWIG_IsOK(ecode2)) {
45645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45646 }
45647 arg2 = static_cast< float >(val2);
45648 {
45649 PyThreadState* __tstate = wxPyBeginAllowThreads();
45650 (arg1)->SetRatio(arg2);
45651 wxPyEndAllowThreads(__tstate);
45652 if (PyErr_Occurred()) SWIG_fail;
45653 }
45654 resultobj = SWIG_Py_Void();
45655 return resultobj;
45656 fail:
45657 return NULL;
45658 }
45659
45660
45661 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45662 PyObject *resultobj = 0;
45663 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45664 float result;
45665 void *argp1 = 0 ;
45666 int res1 = 0 ;
45667 PyObject *swig_obj[1] ;
45668
45669 if (!args) SWIG_fail;
45670 swig_obj[0] = args;
45671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45672 if (!SWIG_IsOK(res1)) {
45673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45674 }
45675 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45676 {
45677 PyThreadState* __tstate = wxPyBeginAllowThreads();
45678 result = (float)(arg1)->GetRatio();
45679 wxPyEndAllowThreads(__tstate);
45680 if (PyErr_Occurred()) SWIG_fail;
45681 }
45682 resultobj = SWIG_From_float(static_cast< float >(result));
45683 return resultobj;
45684 fail:
45685 return NULL;
45686 }
45687
45688
45689 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45690 PyObject *resultobj = 0;
45691 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45692 wxRect result;
45693 void *argp1 = 0 ;
45694 int res1 = 0 ;
45695 PyObject *swig_obj[1] ;
45696
45697 if (!args) SWIG_fail;
45698 swig_obj[0] = args;
45699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45700 if (!SWIG_IsOK(res1)) {
45701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45702 }
45703 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45704 {
45705 PyThreadState* __tstate = wxPyBeginAllowThreads();
45706 result = (arg1)->GetRect();
45707 wxPyEndAllowThreads(__tstate);
45708 if (PyErr_Occurred()) SWIG_fail;
45709 }
45710 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45711 return resultobj;
45712 fail:
45713 return NULL;
45714 }
45715
45716
45717 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45718 PyObject *resultobj = 0;
45719 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45720 bool result;
45721 void *argp1 = 0 ;
45722 int res1 = 0 ;
45723 PyObject *swig_obj[1] ;
45724
45725 if (!args) SWIG_fail;
45726 swig_obj[0] = args;
45727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45728 if (!SWIG_IsOK(res1)) {
45729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45730 }
45731 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45732 {
45733 PyThreadState* __tstate = wxPyBeginAllowThreads();
45734 result = (bool)(arg1)->IsWindow();
45735 wxPyEndAllowThreads(__tstate);
45736 if (PyErr_Occurred()) SWIG_fail;
45737 }
45738 {
45739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45740 }
45741 return resultobj;
45742 fail:
45743 return NULL;
45744 }
45745
45746
45747 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45748 PyObject *resultobj = 0;
45749 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45750 bool result;
45751 void *argp1 = 0 ;
45752 int res1 = 0 ;
45753 PyObject *swig_obj[1] ;
45754
45755 if (!args) SWIG_fail;
45756 swig_obj[0] = args;
45757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45758 if (!SWIG_IsOK(res1)) {
45759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45760 }
45761 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45762 {
45763 PyThreadState* __tstate = wxPyBeginAllowThreads();
45764 result = (bool)(arg1)->IsSizer();
45765 wxPyEndAllowThreads(__tstate);
45766 if (PyErr_Occurred()) SWIG_fail;
45767 }
45768 {
45769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45770 }
45771 return resultobj;
45772 fail:
45773 return NULL;
45774 }
45775
45776
45777 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45778 PyObject *resultobj = 0;
45779 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45780 bool result;
45781 void *argp1 = 0 ;
45782 int res1 = 0 ;
45783 PyObject *swig_obj[1] ;
45784
45785 if (!args) SWIG_fail;
45786 swig_obj[0] = args;
45787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45788 if (!SWIG_IsOK(res1)) {
45789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45790 }
45791 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45792 {
45793 PyThreadState* __tstate = wxPyBeginAllowThreads();
45794 result = (bool)(arg1)->IsSpacer();
45795 wxPyEndAllowThreads(__tstate);
45796 if (PyErr_Occurred()) SWIG_fail;
45797 }
45798 {
45799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45800 }
45801 return resultobj;
45802 fail:
45803 return NULL;
45804 }
45805
45806
45807 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45808 PyObject *resultobj = 0;
45809 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45810 int arg2 ;
45811 void *argp1 = 0 ;
45812 int res1 = 0 ;
45813 int val2 ;
45814 int ecode2 = 0 ;
45815 PyObject * obj0 = 0 ;
45816 PyObject * obj1 = 0 ;
45817 char * kwnames[] = {
45818 (char *) "self",(char *) "proportion", NULL
45819 };
45820
45821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45823 if (!SWIG_IsOK(res1)) {
45824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45825 }
45826 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45827 ecode2 = SWIG_AsVal_int(obj1, &val2);
45828 if (!SWIG_IsOK(ecode2)) {
45829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45830 }
45831 arg2 = static_cast< int >(val2);
45832 {
45833 PyThreadState* __tstate = wxPyBeginAllowThreads();
45834 (arg1)->SetProportion(arg2);
45835 wxPyEndAllowThreads(__tstate);
45836 if (PyErr_Occurred()) SWIG_fail;
45837 }
45838 resultobj = SWIG_Py_Void();
45839 return resultobj;
45840 fail:
45841 return NULL;
45842 }
45843
45844
45845 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45846 PyObject *resultobj = 0;
45847 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45848 int result;
45849 void *argp1 = 0 ;
45850 int res1 = 0 ;
45851 PyObject *swig_obj[1] ;
45852
45853 if (!args) SWIG_fail;
45854 swig_obj[0] = args;
45855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45856 if (!SWIG_IsOK(res1)) {
45857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45858 }
45859 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45860 {
45861 PyThreadState* __tstate = wxPyBeginAllowThreads();
45862 result = (int)(arg1)->GetProportion();
45863 wxPyEndAllowThreads(__tstate);
45864 if (PyErr_Occurred()) SWIG_fail;
45865 }
45866 resultobj = SWIG_From_int(static_cast< int >(result));
45867 return resultobj;
45868 fail:
45869 return NULL;
45870 }
45871
45872
45873 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45874 PyObject *resultobj = 0;
45875 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45876 int arg2 ;
45877 void *argp1 = 0 ;
45878 int res1 = 0 ;
45879 int val2 ;
45880 int ecode2 = 0 ;
45881 PyObject * obj0 = 0 ;
45882 PyObject * obj1 = 0 ;
45883 char * kwnames[] = {
45884 (char *) "self",(char *) "flag", NULL
45885 };
45886
45887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45889 if (!SWIG_IsOK(res1)) {
45890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45891 }
45892 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45893 ecode2 = SWIG_AsVal_int(obj1, &val2);
45894 if (!SWIG_IsOK(ecode2)) {
45895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45896 }
45897 arg2 = static_cast< int >(val2);
45898 {
45899 PyThreadState* __tstate = wxPyBeginAllowThreads();
45900 (arg1)->SetFlag(arg2);
45901 wxPyEndAllowThreads(__tstate);
45902 if (PyErr_Occurred()) SWIG_fail;
45903 }
45904 resultobj = SWIG_Py_Void();
45905 return resultobj;
45906 fail:
45907 return NULL;
45908 }
45909
45910
45911 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45912 PyObject *resultobj = 0;
45913 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45914 int result;
45915 void *argp1 = 0 ;
45916 int res1 = 0 ;
45917 PyObject *swig_obj[1] ;
45918
45919 if (!args) SWIG_fail;
45920 swig_obj[0] = args;
45921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45922 if (!SWIG_IsOK(res1)) {
45923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45924 }
45925 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45926 {
45927 PyThreadState* __tstate = wxPyBeginAllowThreads();
45928 result = (int)(arg1)->GetFlag();
45929 wxPyEndAllowThreads(__tstate);
45930 if (PyErr_Occurred()) SWIG_fail;
45931 }
45932 resultobj = SWIG_From_int(static_cast< int >(result));
45933 return resultobj;
45934 fail:
45935 return NULL;
45936 }
45937
45938
45939 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45940 PyObject *resultobj = 0;
45941 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45942 int arg2 ;
45943 void *argp1 = 0 ;
45944 int res1 = 0 ;
45945 int val2 ;
45946 int ecode2 = 0 ;
45947 PyObject * obj0 = 0 ;
45948 PyObject * obj1 = 0 ;
45949 char * kwnames[] = {
45950 (char *) "self",(char *) "border", NULL
45951 };
45952
45953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45955 if (!SWIG_IsOK(res1)) {
45956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45957 }
45958 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45959 ecode2 = SWIG_AsVal_int(obj1, &val2);
45960 if (!SWIG_IsOK(ecode2)) {
45961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45962 }
45963 arg2 = static_cast< int >(val2);
45964 {
45965 PyThreadState* __tstate = wxPyBeginAllowThreads();
45966 (arg1)->SetBorder(arg2);
45967 wxPyEndAllowThreads(__tstate);
45968 if (PyErr_Occurred()) SWIG_fail;
45969 }
45970 resultobj = SWIG_Py_Void();
45971 return resultobj;
45972 fail:
45973 return NULL;
45974 }
45975
45976
45977 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45978 PyObject *resultobj = 0;
45979 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45980 int result;
45981 void *argp1 = 0 ;
45982 int res1 = 0 ;
45983 PyObject *swig_obj[1] ;
45984
45985 if (!args) SWIG_fail;
45986 swig_obj[0] = args;
45987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45988 if (!SWIG_IsOK(res1)) {
45989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45990 }
45991 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45992 {
45993 PyThreadState* __tstate = wxPyBeginAllowThreads();
45994 result = (int)(arg1)->GetBorder();
45995 wxPyEndAllowThreads(__tstate);
45996 if (PyErr_Occurred()) SWIG_fail;
45997 }
45998 resultobj = SWIG_From_int(static_cast< int >(result));
45999 return resultobj;
46000 fail:
46001 return NULL;
46002 }
46003
46004
46005 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46006 PyObject *resultobj = 0;
46007 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46008 wxWindow *result = 0 ;
46009 void *argp1 = 0 ;
46010 int res1 = 0 ;
46011 PyObject *swig_obj[1] ;
46012
46013 if (!args) SWIG_fail;
46014 swig_obj[0] = args;
46015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46016 if (!SWIG_IsOK(res1)) {
46017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46018 }
46019 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46020 {
46021 PyThreadState* __tstate = wxPyBeginAllowThreads();
46022 result = (wxWindow *)(arg1)->GetWindow();
46023 wxPyEndAllowThreads(__tstate);
46024 if (PyErr_Occurred()) SWIG_fail;
46025 }
46026 {
46027 resultobj = wxPyMake_wxObject(result, 0);
46028 }
46029 return resultobj;
46030 fail:
46031 return NULL;
46032 }
46033
46034
46035 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46036 PyObject *resultobj = 0;
46037 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46038 wxWindow *arg2 = (wxWindow *) 0 ;
46039 void *argp1 = 0 ;
46040 int res1 = 0 ;
46041 void *argp2 = 0 ;
46042 int res2 = 0 ;
46043 PyObject * obj0 = 0 ;
46044 PyObject * obj1 = 0 ;
46045 char * kwnames[] = {
46046 (char *) "self",(char *) "window", NULL
46047 };
46048
46049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46051 if (!SWIG_IsOK(res1)) {
46052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46053 }
46054 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46055 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46056 if (!SWIG_IsOK(res2)) {
46057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46058 }
46059 arg2 = reinterpret_cast< wxWindow * >(argp2);
46060 {
46061 PyThreadState* __tstate = wxPyBeginAllowThreads();
46062 (arg1)->SetWindow(arg2);
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_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46074 PyObject *resultobj = 0;
46075 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46076 wxSizer *result = 0 ;
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_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46086 }
46087 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46088 {
46089 PyThreadState* __tstate = wxPyBeginAllowThreads();
46090 result = (wxSizer *)(arg1)->GetSizer();
46091 wxPyEndAllowThreads(__tstate);
46092 if (PyErr_Occurred()) SWIG_fail;
46093 }
46094 {
46095 resultobj = wxPyMake_wxObject(result, (bool)0);
46096 }
46097 return resultobj;
46098 fail:
46099 return NULL;
46100 }
46101
46102
46103 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46104 PyObject *resultobj = 0;
46105 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46106 wxSizer *arg2 = (wxSizer *) 0 ;
46107 void *argp1 = 0 ;
46108 int res1 = 0 ;
46109 int res2 = 0 ;
46110 PyObject * obj0 = 0 ;
46111 PyObject * obj1 = 0 ;
46112 char * kwnames[] = {
46113 (char *) "self",(char *) "sizer", NULL
46114 };
46115
46116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46118 if (!SWIG_IsOK(res1)) {
46119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46120 }
46121 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46122 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46123 if (!SWIG_IsOK(res2)) {
46124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46125 }
46126 {
46127 PyThreadState* __tstate = wxPyBeginAllowThreads();
46128 (arg1)->SetSizer(arg2);
46129 wxPyEndAllowThreads(__tstate);
46130 if (PyErr_Occurred()) SWIG_fail;
46131 }
46132 resultobj = SWIG_Py_Void();
46133 return resultobj;
46134 fail:
46135 return NULL;
46136 }
46137
46138
46139 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46140 PyObject *resultobj = 0;
46141 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46142 wxSize *result = 0 ;
46143 void *argp1 = 0 ;
46144 int res1 = 0 ;
46145 PyObject *swig_obj[1] ;
46146
46147 if (!args) SWIG_fail;
46148 swig_obj[0] = args;
46149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46150 if (!SWIG_IsOK(res1)) {
46151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46152 }
46153 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46154 {
46155 PyThreadState* __tstate = wxPyBeginAllowThreads();
46156 {
46157 wxSize const &_result_ref = (arg1)->GetSpacer();
46158 result = (wxSize *) &_result_ref;
46159 }
46160 wxPyEndAllowThreads(__tstate);
46161 if (PyErr_Occurred()) SWIG_fail;
46162 }
46163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46164 return resultobj;
46165 fail:
46166 return NULL;
46167 }
46168
46169
46170 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46171 PyObject *resultobj = 0;
46172 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46173 wxSize *arg2 = 0 ;
46174 void *argp1 = 0 ;
46175 int res1 = 0 ;
46176 wxSize temp2 ;
46177 PyObject * obj0 = 0 ;
46178 PyObject * obj1 = 0 ;
46179 char * kwnames[] = {
46180 (char *) "self",(char *) "size", NULL
46181 };
46182
46183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46185 if (!SWIG_IsOK(res1)) {
46186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46187 }
46188 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46189 {
46190 arg2 = &temp2;
46191 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46192 }
46193 {
46194 PyThreadState* __tstate = wxPyBeginAllowThreads();
46195 (arg1)->SetSpacer((wxSize const &)*arg2);
46196 wxPyEndAllowThreads(__tstate);
46197 if (PyErr_Occurred()) SWIG_fail;
46198 }
46199 resultobj = SWIG_Py_Void();
46200 return resultobj;
46201 fail:
46202 return NULL;
46203 }
46204
46205
46206 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46207 PyObject *resultobj = 0;
46208 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46209 bool arg2 ;
46210 void *argp1 = 0 ;
46211 int res1 = 0 ;
46212 bool val2 ;
46213 int ecode2 = 0 ;
46214 PyObject * obj0 = 0 ;
46215 PyObject * obj1 = 0 ;
46216 char * kwnames[] = {
46217 (char *) "self",(char *) "show", NULL
46218 };
46219
46220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46222 if (!SWIG_IsOK(res1)) {
46223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46224 }
46225 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46226 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46227 if (!SWIG_IsOK(ecode2)) {
46228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46229 }
46230 arg2 = static_cast< bool >(val2);
46231 {
46232 PyThreadState* __tstate = wxPyBeginAllowThreads();
46233 (arg1)->Show(arg2);
46234 wxPyEndAllowThreads(__tstate);
46235 if (PyErr_Occurred()) SWIG_fail;
46236 }
46237 resultobj = SWIG_Py_Void();
46238 return resultobj;
46239 fail:
46240 return NULL;
46241 }
46242
46243
46244 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46245 PyObject *resultobj = 0;
46246 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46247 bool result;
46248 void *argp1 = 0 ;
46249 int res1 = 0 ;
46250 PyObject *swig_obj[1] ;
46251
46252 if (!args) SWIG_fail;
46253 swig_obj[0] = args;
46254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46255 if (!SWIG_IsOK(res1)) {
46256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46257 }
46258 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46259 {
46260 PyThreadState* __tstate = wxPyBeginAllowThreads();
46261 result = (bool)(arg1)->IsShown();
46262 wxPyEndAllowThreads(__tstate);
46263 if (PyErr_Occurred()) SWIG_fail;
46264 }
46265 {
46266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46267 }
46268 return resultobj;
46269 fail:
46270 return NULL;
46271 }
46272
46273
46274 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46275 PyObject *resultobj = 0;
46276 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46277 wxPoint result;
46278 void *argp1 = 0 ;
46279 int res1 = 0 ;
46280 PyObject *swig_obj[1] ;
46281
46282 if (!args) SWIG_fail;
46283 swig_obj[0] = args;
46284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46285 if (!SWIG_IsOK(res1)) {
46286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46287 }
46288 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46289 {
46290 PyThreadState* __tstate = wxPyBeginAllowThreads();
46291 result = (arg1)->GetPosition();
46292 wxPyEndAllowThreads(__tstate);
46293 if (PyErr_Occurred()) SWIG_fail;
46294 }
46295 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46296 return resultobj;
46297 fail:
46298 return NULL;
46299 }
46300
46301
46302 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46303 PyObject *resultobj = 0;
46304 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46305 PyObject *result = 0 ;
46306 void *argp1 = 0 ;
46307 int res1 = 0 ;
46308 PyObject *swig_obj[1] ;
46309
46310 if (!args) SWIG_fail;
46311 swig_obj[0] = args;
46312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46313 if (!SWIG_IsOK(res1)) {
46314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46315 }
46316 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46317 {
46318 PyThreadState* __tstate = wxPyBeginAllowThreads();
46319 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46320 wxPyEndAllowThreads(__tstate);
46321 if (PyErr_Occurred()) SWIG_fail;
46322 }
46323 resultobj = result;
46324 return resultobj;
46325 fail:
46326 return NULL;
46327 }
46328
46329
46330 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46331 PyObject *resultobj = 0;
46332 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46333 PyObject *arg2 = (PyObject *) 0 ;
46334 void *argp1 = 0 ;
46335 int res1 = 0 ;
46336 PyObject * obj0 = 0 ;
46337 PyObject * obj1 = 0 ;
46338 char * kwnames[] = {
46339 (char *) "self",(char *) "userData", NULL
46340 };
46341
46342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46344 if (!SWIG_IsOK(res1)) {
46345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46346 }
46347 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46348 arg2 = obj1;
46349 {
46350 PyThreadState* __tstate = wxPyBeginAllowThreads();
46351 wxSizerItem_SetUserData(arg1,arg2);
46352 wxPyEndAllowThreads(__tstate);
46353 if (PyErr_Occurred()) SWIG_fail;
46354 }
46355 resultobj = SWIG_Py_Void();
46356 return resultobj;
46357 fail:
46358 return NULL;
46359 }
46360
46361
46362 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46363 PyObject *obj;
46364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46365 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46366 return SWIG_Py_Void();
46367 }
46368
46369 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46370 return SWIG_Python_InitShadowInstance(args);
46371 }
46372
46373 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46374 PyObject *resultobj = 0;
46375 wxSizer *arg1 = (wxSizer *) 0 ;
46376 void *argp1 = 0 ;
46377 int res1 = 0 ;
46378 PyObject *swig_obj[1] ;
46379
46380 if (!args) SWIG_fail;
46381 swig_obj[0] = args;
46382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46383 if (!SWIG_IsOK(res1)) {
46384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46385 }
46386 arg1 = reinterpret_cast< wxSizer * >(argp1);
46387 {
46388 PyThreadState* __tstate = wxPyBeginAllowThreads();
46389 delete arg1;
46390
46391 wxPyEndAllowThreads(__tstate);
46392 if (PyErr_Occurred()) SWIG_fail;
46393 }
46394 resultobj = SWIG_Py_Void();
46395 return resultobj;
46396 fail:
46397 return NULL;
46398 }
46399
46400
46401 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46402 PyObject *resultobj = 0;
46403 wxSizer *arg1 = (wxSizer *) 0 ;
46404 PyObject *arg2 = (PyObject *) 0 ;
46405 void *argp1 = 0 ;
46406 int res1 = 0 ;
46407 PyObject * obj0 = 0 ;
46408 PyObject * obj1 = 0 ;
46409 char * kwnames[] = {
46410 (char *) "self",(char *) "_self", NULL
46411 };
46412
46413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46415 if (!SWIG_IsOK(res1)) {
46416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46417 }
46418 arg1 = reinterpret_cast< wxSizer * >(argp1);
46419 arg2 = obj1;
46420 {
46421 PyThreadState* __tstate = wxPyBeginAllowThreads();
46422 wxSizer__setOORInfo(arg1,arg2);
46423 wxPyEndAllowThreads(__tstate);
46424 if (PyErr_Occurred()) SWIG_fail;
46425 }
46426 resultobj = SWIG_Py_Void();
46427 return resultobj;
46428 fail:
46429 return NULL;
46430 }
46431
46432
46433 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46434 PyObject *resultobj = 0;
46435 wxSizer *arg1 = (wxSizer *) 0 ;
46436 PyObject *arg2 = (PyObject *) 0 ;
46437 int arg3 = (int) 0 ;
46438 int arg4 = (int) 0 ;
46439 int arg5 = (int) 0 ;
46440 PyObject *arg6 = (PyObject *) NULL ;
46441 wxSizerItem *result = 0 ;
46442 void *argp1 = 0 ;
46443 int res1 = 0 ;
46444 int val3 ;
46445 int ecode3 = 0 ;
46446 int val4 ;
46447 int ecode4 = 0 ;
46448 int val5 ;
46449 int ecode5 = 0 ;
46450 PyObject * obj0 = 0 ;
46451 PyObject * obj1 = 0 ;
46452 PyObject * obj2 = 0 ;
46453 PyObject * obj3 = 0 ;
46454 PyObject * obj4 = 0 ;
46455 PyObject * obj5 = 0 ;
46456 char * kwnames[] = {
46457 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46458 };
46459
46460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46462 if (!SWIG_IsOK(res1)) {
46463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46464 }
46465 arg1 = reinterpret_cast< wxSizer * >(argp1);
46466 arg2 = obj1;
46467 if (obj2) {
46468 ecode3 = SWIG_AsVal_int(obj2, &val3);
46469 if (!SWIG_IsOK(ecode3)) {
46470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46471 }
46472 arg3 = static_cast< int >(val3);
46473 }
46474 if (obj3) {
46475 ecode4 = SWIG_AsVal_int(obj3, &val4);
46476 if (!SWIG_IsOK(ecode4)) {
46477 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46478 }
46479 arg4 = static_cast< int >(val4);
46480 }
46481 if (obj4) {
46482 ecode5 = SWIG_AsVal_int(obj4, &val5);
46483 if (!SWIG_IsOK(ecode5)) {
46484 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46485 }
46486 arg5 = static_cast< int >(val5);
46487 }
46488 if (obj5) {
46489 arg6 = obj5;
46490 }
46491 {
46492 PyThreadState* __tstate = wxPyBeginAllowThreads();
46493 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46494 wxPyEndAllowThreads(__tstate);
46495 if (PyErr_Occurred()) SWIG_fail;
46496 }
46497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46498 return resultobj;
46499 fail:
46500 return NULL;
46501 }
46502
46503
46504 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46505 PyObject *resultobj = 0;
46506 wxSizer *arg1 = (wxSizer *) 0 ;
46507 int arg2 ;
46508 PyObject *arg3 = (PyObject *) 0 ;
46509 int arg4 = (int) 0 ;
46510 int arg5 = (int) 0 ;
46511 int arg6 = (int) 0 ;
46512 PyObject *arg7 = (PyObject *) NULL ;
46513 wxSizerItem *result = 0 ;
46514 void *argp1 = 0 ;
46515 int res1 = 0 ;
46516 int val2 ;
46517 int ecode2 = 0 ;
46518 int val4 ;
46519 int ecode4 = 0 ;
46520 int val5 ;
46521 int ecode5 = 0 ;
46522 int val6 ;
46523 int ecode6 = 0 ;
46524 PyObject * obj0 = 0 ;
46525 PyObject * obj1 = 0 ;
46526 PyObject * obj2 = 0 ;
46527 PyObject * obj3 = 0 ;
46528 PyObject * obj4 = 0 ;
46529 PyObject * obj5 = 0 ;
46530 PyObject * obj6 = 0 ;
46531 char * kwnames[] = {
46532 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46533 };
46534
46535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46537 if (!SWIG_IsOK(res1)) {
46538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46539 }
46540 arg1 = reinterpret_cast< wxSizer * >(argp1);
46541 ecode2 = SWIG_AsVal_int(obj1, &val2);
46542 if (!SWIG_IsOK(ecode2)) {
46543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46544 }
46545 arg2 = static_cast< int >(val2);
46546 arg3 = obj2;
46547 if (obj3) {
46548 ecode4 = SWIG_AsVal_int(obj3, &val4);
46549 if (!SWIG_IsOK(ecode4)) {
46550 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46551 }
46552 arg4 = static_cast< int >(val4);
46553 }
46554 if (obj4) {
46555 ecode5 = SWIG_AsVal_int(obj4, &val5);
46556 if (!SWIG_IsOK(ecode5)) {
46557 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46558 }
46559 arg5 = static_cast< int >(val5);
46560 }
46561 if (obj5) {
46562 ecode6 = SWIG_AsVal_int(obj5, &val6);
46563 if (!SWIG_IsOK(ecode6)) {
46564 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46565 }
46566 arg6 = static_cast< int >(val6);
46567 }
46568 if (obj6) {
46569 arg7 = obj6;
46570 }
46571 {
46572 PyThreadState* __tstate = wxPyBeginAllowThreads();
46573 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46574 wxPyEndAllowThreads(__tstate);
46575 if (PyErr_Occurred()) SWIG_fail;
46576 }
46577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46578 return resultobj;
46579 fail:
46580 return NULL;
46581 }
46582
46583
46584 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46585 PyObject *resultobj = 0;
46586 wxSizer *arg1 = (wxSizer *) 0 ;
46587 PyObject *arg2 = (PyObject *) 0 ;
46588 int arg3 = (int) 0 ;
46589 int arg4 = (int) 0 ;
46590 int arg5 = (int) 0 ;
46591 PyObject *arg6 = (PyObject *) NULL ;
46592 wxSizerItem *result = 0 ;
46593 void *argp1 = 0 ;
46594 int res1 = 0 ;
46595 int val3 ;
46596 int ecode3 = 0 ;
46597 int val4 ;
46598 int ecode4 = 0 ;
46599 int val5 ;
46600 int ecode5 = 0 ;
46601 PyObject * obj0 = 0 ;
46602 PyObject * obj1 = 0 ;
46603 PyObject * obj2 = 0 ;
46604 PyObject * obj3 = 0 ;
46605 PyObject * obj4 = 0 ;
46606 PyObject * obj5 = 0 ;
46607 char * kwnames[] = {
46608 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46609 };
46610
46611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46613 if (!SWIG_IsOK(res1)) {
46614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46615 }
46616 arg1 = reinterpret_cast< wxSizer * >(argp1);
46617 arg2 = obj1;
46618 if (obj2) {
46619 ecode3 = SWIG_AsVal_int(obj2, &val3);
46620 if (!SWIG_IsOK(ecode3)) {
46621 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46622 }
46623 arg3 = static_cast< int >(val3);
46624 }
46625 if (obj3) {
46626 ecode4 = SWIG_AsVal_int(obj3, &val4);
46627 if (!SWIG_IsOK(ecode4)) {
46628 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46629 }
46630 arg4 = static_cast< int >(val4);
46631 }
46632 if (obj4) {
46633 ecode5 = SWIG_AsVal_int(obj4, &val5);
46634 if (!SWIG_IsOK(ecode5)) {
46635 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46636 }
46637 arg5 = static_cast< int >(val5);
46638 }
46639 if (obj5) {
46640 arg6 = obj5;
46641 }
46642 {
46643 PyThreadState* __tstate = wxPyBeginAllowThreads();
46644 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46645 wxPyEndAllowThreads(__tstate);
46646 if (PyErr_Occurred()) SWIG_fail;
46647 }
46648 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46649 return resultobj;
46650 fail:
46651 return NULL;
46652 }
46653
46654
46655 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46656 PyObject *resultobj = 0;
46657 wxSizer *arg1 = (wxSizer *) 0 ;
46658 PyObject *arg2 = (PyObject *) 0 ;
46659 bool result;
46660 void *argp1 = 0 ;
46661 int res1 = 0 ;
46662 PyObject * obj0 = 0 ;
46663 PyObject * obj1 = 0 ;
46664 char * kwnames[] = {
46665 (char *) "self",(char *) "item", NULL
46666 };
46667
46668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46670 if (!SWIG_IsOK(res1)) {
46671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46672 }
46673 arg1 = reinterpret_cast< wxSizer * >(argp1);
46674 arg2 = obj1;
46675 {
46676 PyThreadState* __tstate = wxPyBeginAllowThreads();
46677 result = (bool)wxSizer_Remove(arg1,arg2);
46678 wxPyEndAllowThreads(__tstate);
46679 if (PyErr_Occurred()) SWIG_fail;
46680 }
46681 {
46682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46683 }
46684 return resultobj;
46685 fail:
46686 return NULL;
46687 }
46688
46689
46690 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46691 PyObject *resultobj = 0;
46692 wxSizer *arg1 = (wxSizer *) 0 ;
46693 PyObject *arg2 = (PyObject *) 0 ;
46694 bool result;
46695 void *argp1 = 0 ;
46696 int res1 = 0 ;
46697 PyObject * obj0 = 0 ;
46698 PyObject * obj1 = 0 ;
46699 char * kwnames[] = {
46700 (char *) "self",(char *) "item", NULL
46701 };
46702
46703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46705 if (!SWIG_IsOK(res1)) {
46706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46707 }
46708 arg1 = reinterpret_cast< wxSizer * >(argp1);
46709 arg2 = obj1;
46710 {
46711 PyThreadState* __tstate = wxPyBeginAllowThreads();
46712 result = (bool)wxSizer_Detach(arg1,arg2);
46713 wxPyEndAllowThreads(__tstate);
46714 if (PyErr_Occurred()) SWIG_fail;
46715 }
46716 {
46717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46718 }
46719 return resultobj;
46720 fail:
46721 return NULL;
46722 }
46723
46724
46725 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46726 PyObject *resultobj = 0;
46727 wxSizer *arg1 = (wxSizer *) 0 ;
46728 PyObject *arg2 = (PyObject *) 0 ;
46729 wxSizerItem *result = 0 ;
46730 void *argp1 = 0 ;
46731 int res1 = 0 ;
46732 PyObject * obj0 = 0 ;
46733 PyObject * obj1 = 0 ;
46734 char * kwnames[] = {
46735 (char *) "self",(char *) "item", NULL
46736 };
46737
46738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46740 if (!SWIG_IsOK(res1)) {
46741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46742 }
46743 arg1 = reinterpret_cast< wxSizer * >(argp1);
46744 arg2 = obj1;
46745 {
46746 PyThreadState* __tstate = wxPyBeginAllowThreads();
46747 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46748 wxPyEndAllowThreads(__tstate);
46749 if (PyErr_Occurred()) SWIG_fail;
46750 }
46751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46752 return resultobj;
46753 fail:
46754 return NULL;
46755 }
46756
46757
46758 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46759 PyObject *resultobj = 0;
46760 wxSizer *arg1 = (wxSizer *) 0 ;
46761 PyObject *arg2 = (PyObject *) 0 ;
46762 wxSize *arg3 = 0 ;
46763 void *argp1 = 0 ;
46764 int res1 = 0 ;
46765 wxSize temp3 ;
46766 PyObject * obj0 = 0 ;
46767 PyObject * obj1 = 0 ;
46768 PyObject * obj2 = 0 ;
46769 char * kwnames[] = {
46770 (char *) "self",(char *) "item",(char *) "size", NULL
46771 };
46772
46773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46775 if (!SWIG_IsOK(res1)) {
46776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46777 }
46778 arg1 = reinterpret_cast< wxSizer * >(argp1);
46779 arg2 = obj1;
46780 {
46781 arg3 = &temp3;
46782 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46783 }
46784 {
46785 PyThreadState* __tstate = wxPyBeginAllowThreads();
46786 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46787 wxPyEndAllowThreads(__tstate);
46788 if (PyErr_Occurred()) SWIG_fail;
46789 }
46790 resultobj = SWIG_Py_Void();
46791 return resultobj;
46792 fail:
46793 return NULL;
46794 }
46795
46796
46797 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46798 PyObject *resultobj = 0;
46799 wxSizer *arg1 = (wxSizer *) 0 ;
46800 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46801 wxSizerItem *result = 0 ;
46802 void *argp1 = 0 ;
46803 int res1 = 0 ;
46804 int res2 = 0 ;
46805 PyObject * obj0 = 0 ;
46806 PyObject * obj1 = 0 ;
46807 char * kwnames[] = {
46808 (char *) "self",(char *) "item", NULL
46809 };
46810
46811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46813 if (!SWIG_IsOK(res1)) {
46814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46815 }
46816 arg1 = reinterpret_cast< wxSizer * >(argp1);
46817 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46818 if (!SWIG_IsOK(res2)) {
46819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46820 }
46821 {
46822 PyThreadState* __tstate = wxPyBeginAllowThreads();
46823 result = (wxSizerItem *)(arg1)->Add(arg2);
46824 wxPyEndAllowThreads(__tstate);
46825 if (PyErr_Occurred()) SWIG_fail;
46826 }
46827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46828 return resultobj;
46829 fail:
46830 return NULL;
46831 }
46832
46833
46834 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46835 PyObject *resultobj = 0;
46836 wxSizer *arg1 = (wxSizer *) 0 ;
46837 size_t arg2 ;
46838 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46839 wxSizerItem *result = 0 ;
46840 void *argp1 = 0 ;
46841 int res1 = 0 ;
46842 size_t val2 ;
46843 int ecode2 = 0 ;
46844 int res3 = 0 ;
46845 PyObject * obj0 = 0 ;
46846 PyObject * obj1 = 0 ;
46847 PyObject * obj2 = 0 ;
46848 char * kwnames[] = {
46849 (char *) "self",(char *) "index",(char *) "item", NULL
46850 };
46851
46852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46854 if (!SWIG_IsOK(res1)) {
46855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46856 }
46857 arg1 = reinterpret_cast< wxSizer * >(argp1);
46858 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46859 if (!SWIG_IsOK(ecode2)) {
46860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46861 }
46862 arg2 = static_cast< size_t >(val2);
46863 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46864 if (!SWIG_IsOK(res3)) {
46865 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46866 }
46867 {
46868 PyThreadState* __tstate = wxPyBeginAllowThreads();
46869 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46870 wxPyEndAllowThreads(__tstate);
46871 if (PyErr_Occurred()) SWIG_fail;
46872 }
46873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46874 return resultobj;
46875 fail:
46876 return NULL;
46877 }
46878
46879
46880 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46881 PyObject *resultobj = 0;
46882 wxSizer *arg1 = (wxSizer *) 0 ;
46883 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46884 wxSizerItem *result = 0 ;
46885 void *argp1 = 0 ;
46886 int res1 = 0 ;
46887 int res2 = 0 ;
46888 PyObject * obj0 = 0 ;
46889 PyObject * obj1 = 0 ;
46890 char * kwnames[] = {
46891 (char *) "self",(char *) "item", NULL
46892 };
46893
46894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46896 if (!SWIG_IsOK(res1)) {
46897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46898 }
46899 arg1 = reinterpret_cast< wxSizer * >(argp1);
46900 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46901 if (!SWIG_IsOK(res2)) {
46902 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46903 }
46904 {
46905 PyThreadState* __tstate = wxPyBeginAllowThreads();
46906 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46907 wxPyEndAllowThreads(__tstate);
46908 if (PyErr_Occurred()) SWIG_fail;
46909 }
46910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46911 return resultobj;
46912 fail:
46913 return NULL;
46914 }
46915
46916
46917 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46918 PyObject *resultobj = 0;
46919 wxSizer *arg1 = (wxSizer *) 0 ;
46920 int arg2 ;
46921 int arg3 ;
46922 int arg4 ;
46923 int arg5 ;
46924 void *argp1 = 0 ;
46925 int res1 = 0 ;
46926 int val2 ;
46927 int ecode2 = 0 ;
46928 int val3 ;
46929 int ecode3 = 0 ;
46930 int val4 ;
46931 int ecode4 = 0 ;
46932 int val5 ;
46933 int ecode5 = 0 ;
46934 PyObject * obj0 = 0 ;
46935 PyObject * obj1 = 0 ;
46936 PyObject * obj2 = 0 ;
46937 PyObject * obj3 = 0 ;
46938 PyObject * obj4 = 0 ;
46939 char * kwnames[] = {
46940 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46941 };
46942
46943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46945 if (!SWIG_IsOK(res1)) {
46946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46947 }
46948 arg1 = reinterpret_cast< wxSizer * >(argp1);
46949 ecode2 = SWIG_AsVal_int(obj1, &val2);
46950 if (!SWIG_IsOK(ecode2)) {
46951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46952 }
46953 arg2 = static_cast< int >(val2);
46954 ecode3 = SWIG_AsVal_int(obj2, &val3);
46955 if (!SWIG_IsOK(ecode3)) {
46956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46957 }
46958 arg3 = static_cast< int >(val3);
46959 ecode4 = SWIG_AsVal_int(obj3, &val4);
46960 if (!SWIG_IsOK(ecode4)) {
46961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46962 }
46963 arg4 = static_cast< int >(val4);
46964 ecode5 = SWIG_AsVal_int(obj4, &val5);
46965 if (!SWIG_IsOK(ecode5)) {
46966 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46967 }
46968 arg5 = static_cast< int >(val5);
46969 {
46970 PyThreadState* __tstate = wxPyBeginAllowThreads();
46971 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46972 wxPyEndAllowThreads(__tstate);
46973 if (PyErr_Occurred()) SWIG_fail;
46974 }
46975 resultobj = SWIG_Py_Void();
46976 return resultobj;
46977 fail:
46978 return NULL;
46979 }
46980
46981
46982 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46983 PyObject *resultobj = 0;
46984 wxSizer *arg1 = (wxSizer *) 0 ;
46985 wxSize *arg2 = 0 ;
46986 void *argp1 = 0 ;
46987 int res1 = 0 ;
46988 wxSize temp2 ;
46989 PyObject * obj0 = 0 ;
46990 PyObject * obj1 = 0 ;
46991 char * kwnames[] = {
46992 (char *) "self",(char *) "size", NULL
46993 };
46994
46995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46997 if (!SWIG_IsOK(res1)) {
46998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46999 }
47000 arg1 = reinterpret_cast< wxSizer * >(argp1);
47001 {
47002 arg2 = &temp2;
47003 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47004 }
47005 {
47006 PyThreadState* __tstate = wxPyBeginAllowThreads();
47007 (arg1)->SetMinSize((wxSize const &)*arg2);
47008 wxPyEndAllowThreads(__tstate);
47009 if (PyErr_Occurred()) SWIG_fail;
47010 }
47011 resultobj = SWIG_Py_Void();
47012 return resultobj;
47013 fail:
47014 return NULL;
47015 }
47016
47017
47018 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47019 PyObject *resultobj = 0;
47020 wxSizer *arg1 = (wxSizer *) 0 ;
47021 wxSize result;
47022 void *argp1 = 0 ;
47023 int res1 = 0 ;
47024 PyObject *swig_obj[1] ;
47025
47026 if (!args) SWIG_fail;
47027 swig_obj[0] = args;
47028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47029 if (!SWIG_IsOK(res1)) {
47030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47031 }
47032 arg1 = reinterpret_cast< wxSizer * >(argp1);
47033 {
47034 PyThreadState* __tstate = wxPyBeginAllowThreads();
47035 result = (arg1)->GetSize();
47036 wxPyEndAllowThreads(__tstate);
47037 if (PyErr_Occurred()) SWIG_fail;
47038 }
47039 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47040 return resultobj;
47041 fail:
47042 return NULL;
47043 }
47044
47045
47046 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47047 PyObject *resultobj = 0;
47048 wxSizer *arg1 = (wxSizer *) 0 ;
47049 wxPoint result;
47050 void *argp1 = 0 ;
47051 int res1 = 0 ;
47052 PyObject *swig_obj[1] ;
47053
47054 if (!args) SWIG_fail;
47055 swig_obj[0] = args;
47056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47057 if (!SWIG_IsOK(res1)) {
47058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47059 }
47060 arg1 = reinterpret_cast< wxSizer * >(argp1);
47061 {
47062 PyThreadState* __tstate = wxPyBeginAllowThreads();
47063 result = (arg1)->GetPosition();
47064 wxPyEndAllowThreads(__tstate);
47065 if (PyErr_Occurred()) SWIG_fail;
47066 }
47067 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47068 return resultobj;
47069 fail:
47070 return NULL;
47071 }
47072
47073
47074 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47075 PyObject *resultobj = 0;
47076 wxSizer *arg1 = (wxSizer *) 0 ;
47077 wxSize result;
47078 void *argp1 = 0 ;
47079 int res1 = 0 ;
47080 PyObject *swig_obj[1] ;
47081
47082 if (!args) SWIG_fail;
47083 swig_obj[0] = args;
47084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47085 if (!SWIG_IsOK(res1)) {
47086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47087 }
47088 arg1 = reinterpret_cast< wxSizer * >(argp1);
47089 {
47090 PyThreadState* __tstate = wxPyBeginAllowThreads();
47091 result = (arg1)->GetMinSize();
47092 wxPyEndAllowThreads(__tstate);
47093 if (PyErr_Occurred()) SWIG_fail;
47094 }
47095 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47096 return resultobj;
47097 fail:
47098 return NULL;
47099 }
47100
47101
47102 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47103 PyObject *resultobj = 0;
47104 wxSizer *arg1 = (wxSizer *) 0 ;
47105 void *argp1 = 0 ;
47106 int res1 = 0 ;
47107 PyObject *swig_obj[1] ;
47108
47109 if (!args) SWIG_fail;
47110 swig_obj[0] = args;
47111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47112 if (!SWIG_IsOK(res1)) {
47113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47114 }
47115 arg1 = reinterpret_cast< wxSizer * >(argp1);
47116 {
47117 PyThreadState* __tstate = wxPyBeginAllowThreads();
47118 (arg1)->RecalcSizes();
47119 wxPyEndAllowThreads(__tstate);
47120 if (PyErr_Occurred()) SWIG_fail;
47121 }
47122 resultobj = SWIG_Py_Void();
47123 return resultobj;
47124 fail:
47125 return NULL;
47126 }
47127
47128
47129 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47130 PyObject *resultobj = 0;
47131 wxSizer *arg1 = (wxSizer *) 0 ;
47132 wxSize result;
47133 void *argp1 = 0 ;
47134 int res1 = 0 ;
47135 PyObject *swig_obj[1] ;
47136
47137 if (!args) SWIG_fail;
47138 swig_obj[0] = args;
47139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47140 if (!SWIG_IsOK(res1)) {
47141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47142 }
47143 arg1 = reinterpret_cast< wxSizer * >(argp1);
47144 {
47145 PyThreadState* __tstate = wxPyBeginAllowThreads();
47146 result = (arg1)->CalcMin();
47147 wxPyEndAllowThreads(__tstate);
47148 if (PyErr_Occurred()) SWIG_fail;
47149 }
47150 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47151 return resultobj;
47152 fail:
47153 return NULL;
47154 }
47155
47156
47157 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47158 PyObject *resultobj = 0;
47159 wxSizer *arg1 = (wxSizer *) 0 ;
47160 void *argp1 = 0 ;
47161 int res1 = 0 ;
47162 PyObject *swig_obj[1] ;
47163
47164 if (!args) SWIG_fail;
47165 swig_obj[0] = args;
47166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47167 if (!SWIG_IsOK(res1)) {
47168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47169 }
47170 arg1 = reinterpret_cast< wxSizer * >(argp1);
47171 {
47172 PyThreadState* __tstate = wxPyBeginAllowThreads();
47173 (arg1)->Layout();
47174 wxPyEndAllowThreads(__tstate);
47175 if (PyErr_Occurred()) SWIG_fail;
47176 }
47177 resultobj = SWIG_Py_Void();
47178 return resultobj;
47179 fail:
47180 return NULL;
47181 }
47182
47183
47184 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47185 PyObject *resultobj = 0;
47186 wxSizer *arg1 = (wxSizer *) 0 ;
47187 wxWindow *arg2 = (wxWindow *) 0 ;
47188 wxSize result;
47189 void *argp1 = 0 ;
47190 int res1 = 0 ;
47191 void *argp2 = 0 ;
47192 int res2 = 0 ;
47193 PyObject * obj0 = 0 ;
47194 PyObject * obj1 = 0 ;
47195 char * kwnames[] = {
47196 (char *) "self",(char *) "window", NULL
47197 };
47198
47199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47201 if (!SWIG_IsOK(res1)) {
47202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47203 }
47204 arg1 = reinterpret_cast< wxSizer * >(argp1);
47205 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47206 if (!SWIG_IsOK(res2)) {
47207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47208 }
47209 arg2 = reinterpret_cast< wxWindow * >(argp2);
47210 {
47211 PyThreadState* __tstate = wxPyBeginAllowThreads();
47212 result = (arg1)->Fit(arg2);
47213 wxPyEndAllowThreads(__tstate);
47214 if (PyErr_Occurred()) SWIG_fail;
47215 }
47216 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47217 return resultobj;
47218 fail:
47219 return NULL;
47220 }
47221
47222
47223 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47224 PyObject *resultobj = 0;
47225 wxSizer *arg1 = (wxSizer *) 0 ;
47226 wxWindow *arg2 = (wxWindow *) 0 ;
47227 void *argp1 = 0 ;
47228 int res1 = 0 ;
47229 void *argp2 = 0 ;
47230 int res2 = 0 ;
47231 PyObject * obj0 = 0 ;
47232 PyObject * obj1 = 0 ;
47233 char * kwnames[] = {
47234 (char *) "self",(char *) "window", NULL
47235 };
47236
47237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47239 if (!SWIG_IsOK(res1)) {
47240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47241 }
47242 arg1 = reinterpret_cast< wxSizer * >(argp1);
47243 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47244 if (!SWIG_IsOK(res2)) {
47245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47246 }
47247 arg2 = reinterpret_cast< wxWindow * >(argp2);
47248 {
47249 PyThreadState* __tstate = wxPyBeginAllowThreads();
47250 (arg1)->FitInside(arg2);
47251 wxPyEndAllowThreads(__tstate);
47252 if (PyErr_Occurred()) SWIG_fail;
47253 }
47254 resultobj = SWIG_Py_Void();
47255 return resultobj;
47256 fail:
47257 return NULL;
47258 }
47259
47260
47261 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47262 PyObject *resultobj = 0;
47263 wxSizer *arg1 = (wxSizer *) 0 ;
47264 wxWindow *arg2 = (wxWindow *) 0 ;
47265 void *argp1 = 0 ;
47266 int res1 = 0 ;
47267 void *argp2 = 0 ;
47268 int res2 = 0 ;
47269 PyObject * obj0 = 0 ;
47270 PyObject * obj1 = 0 ;
47271 char * kwnames[] = {
47272 (char *) "self",(char *) "window", NULL
47273 };
47274
47275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47277 if (!SWIG_IsOK(res1)) {
47278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47279 }
47280 arg1 = reinterpret_cast< wxSizer * >(argp1);
47281 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47282 if (!SWIG_IsOK(res2)) {
47283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47284 }
47285 arg2 = reinterpret_cast< wxWindow * >(argp2);
47286 {
47287 PyThreadState* __tstate = wxPyBeginAllowThreads();
47288 (arg1)->SetSizeHints(arg2);
47289 wxPyEndAllowThreads(__tstate);
47290 if (PyErr_Occurred()) SWIG_fail;
47291 }
47292 resultobj = SWIG_Py_Void();
47293 return resultobj;
47294 fail:
47295 return NULL;
47296 }
47297
47298
47299 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47300 PyObject *resultobj = 0;
47301 wxSizer *arg1 = (wxSizer *) 0 ;
47302 wxWindow *arg2 = (wxWindow *) 0 ;
47303 void *argp1 = 0 ;
47304 int res1 = 0 ;
47305 void *argp2 = 0 ;
47306 int res2 = 0 ;
47307 PyObject * obj0 = 0 ;
47308 PyObject * obj1 = 0 ;
47309 char * kwnames[] = {
47310 (char *) "self",(char *) "window", NULL
47311 };
47312
47313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47315 if (!SWIG_IsOK(res1)) {
47316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47317 }
47318 arg1 = reinterpret_cast< wxSizer * >(argp1);
47319 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47320 if (!SWIG_IsOK(res2)) {
47321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47322 }
47323 arg2 = reinterpret_cast< wxWindow * >(argp2);
47324 {
47325 PyThreadState* __tstate = wxPyBeginAllowThreads();
47326 (arg1)->SetVirtualSizeHints(arg2);
47327 wxPyEndAllowThreads(__tstate);
47328 if (PyErr_Occurred()) SWIG_fail;
47329 }
47330 resultobj = SWIG_Py_Void();
47331 return resultobj;
47332 fail:
47333 return NULL;
47334 }
47335
47336
47337 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47338 PyObject *resultobj = 0;
47339 wxSizer *arg1 = (wxSizer *) 0 ;
47340 bool arg2 = (bool) false ;
47341 void *argp1 = 0 ;
47342 int res1 = 0 ;
47343 bool val2 ;
47344 int ecode2 = 0 ;
47345 PyObject * obj0 = 0 ;
47346 PyObject * obj1 = 0 ;
47347 char * kwnames[] = {
47348 (char *) "self",(char *) "deleteWindows", NULL
47349 };
47350
47351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47353 if (!SWIG_IsOK(res1)) {
47354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47355 }
47356 arg1 = reinterpret_cast< wxSizer * >(argp1);
47357 if (obj1) {
47358 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47359 if (!SWIG_IsOK(ecode2)) {
47360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47361 }
47362 arg2 = static_cast< bool >(val2);
47363 }
47364 {
47365 PyThreadState* __tstate = wxPyBeginAllowThreads();
47366 (arg1)->Clear(arg2);
47367 wxPyEndAllowThreads(__tstate);
47368 if (PyErr_Occurred()) SWIG_fail;
47369 }
47370 resultobj = SWIG_Py_Void();
47371 return resultobj;
47372 fail:
47373 return NULL;
47374 }
47375
47376
47377 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47378 PyObject *resultobj = 0;
47379 wxSizer *arg1 = (wxSizer *) 0 ;
47380 void *argp1 = 0 ;
47381 int res1 = 0 ;
47382 PyObject *swig_obj[1] ;
47383
47384 if (!args) SWIG_fail;
47385 swig_obj[0] = args;
47386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47387 if (!SWIG_IsOK(res1)) {
47388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47389 }
47390 arg1 = reinterpret_cast< wxSizer * >(argp1);
47391 {
47392 PyThreadState* __tstate = wxPyBeginAllowThreads();
47393 (arg1)->DeleteWindows();
47394 wxPyEndAllowThreads(__tstate);
47395 if (PyErr_Occurred()) SWIG_fail;
47396 }
47397 resultobj = SWIG_Py_Void();
47398 return resultobj;
47399 fail:
47400 return NULL;
47401 }
47402
47403
47404 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47405 PyObject *resultobj = 0;
47406 wxSizer *arg1 = (wxSizer *) 0 ;
47407 PyObject *result = 0 ;
47408 void *argp1 = 0 ;
47409 int res1 = 0 ;
47410 PyObject *swig_obj[1] ;
47411
47412 if (!args) SWIG_fail;
47413 swig_obj[0] = args;
47414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47415 if (!SWIG_IsOK(res1)) {
47416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47417 }
47418 arg1 = reinterpret_cast< wxSizer * >(argp1);
47419 {
47420 PyThreadState* __tstate = wxPyBeginAllowThreads();
47421 result = (PyObject *)wxSizer_GetChildren(arg1);
47422 wxPyEndAllowThreads(__tstate);
47423 if (PyErr_Occurred()) SWIG_fail;
47424 }
47425 resultobj = result;
47426 return resultobj;
47427 fail:
47428 return NULL;
47429 }
47430
47431
47432 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47433 PyObject *resultobj = 0;
47434 wxSizer *arg1 = (wxSizer *) 0 ;
47435 PyObject *arg2 = (PyObject *) 0 ;
47436 bool arg3 = (bool) true ;
47437 bool arg4 = (bool) false ;
47438 bool result;
47439 void *argp1 = 0 ;
47440 int res1 = 0 ;
47441 bool val3 ;
47442 int ecode3 = 0 ;
47443 bool val4 ;
47444 int ecode4 = 0 ;
47445 PyObject * obj0 = 0 ;
47446 PyObject * obj1 = 0 ;
47447 PyObject * obj2 = 0 ;
47448 PyObject * obj3 = 0 ;
47449 char * kwnames[] = {
47450 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47451 };
47452
47453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47455 if (!SWIG_IsOK(res1)) {
47456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47457 }
47458 arg1 = reinterpret_cast< wxSizer * >(argp1);
47459 arg2 = obj1;
47460 if (obj2) {
47461 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47462 if (!SWIG_IsOK(ecode3)) {
47463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47464 }
47465 arg3 = static_cast< bool >(val3);
47466 }
47467 if (obj3) {
47468 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47469 if (!SWIG_IsOK(ecode4)) {
47470 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47471 }
47472 arg4 = static_cast< bool >(val4);
47473 }
47474 {
47475 PyThreadState* __tstate = wxPyBeginAllowThreads();
47476 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47477 wxPyEndAllowThreads(__tstate);
47478 if (PyErr_Occurred()) SWIG_fail;
47479 }
47480 {
47481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47482 }
47483 return resultobj;
47484 fail:
47485 return NULL;
47486 }
47487
47488
47489 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47490 PyObject *resultobj = 0;
47491 wxSizer *arg1 = (wxSizer *) 0 ;
47492 PyObject *arg2 = (PyObject *) 0 ;
47493 bool result;
47494 void *argp1 = 0 ;
47495 int res1 = 0 ;
47496 PyObject * obj0 = 0 ;
47497 PyObject * obj1 = 0 ;
47498 char * kwnames[] = {
47499 (char *) "self",(char *) "item", NULL
47500 };
47501
47502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47504 if (!SWIG_IsOK(res1)) {
47505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47506 }
47507 arg1 = reinterpret_cast< wxSizer * >(argp1);
47508 arg2 = obj1;
47509 {
47510 PyThreadState* __tstate = wxPyBeginAllowThreads();
47511 result = (bool)wxSizer_IsShown(arg1,arg2);
47512 wxPyEndAllowThreads(__tstate);
47513 if (PyErr_Occurred()) SWIG_fail;
47514 }
47515 {
47516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47517 }
47518 return resultobj;
47519 fail:
47520 return NULL;
47521 }
47522
47523
47524 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47525 PyObject *resultobj = 0;
47526 wxSizer *arg1 = (wxSizer *) 0 ;
47527 bool arg2 ;
47528 void *argp1 = 0 ;
47529 int res1 = 0 ;
47530 bool val2 ;
47531 int ecode2 = 0 ;
47532 PyObject * obj0 = 0 ;
47533 PyObject * obj1 = 0 ;
47534 char * kwnames[] = {
47535 (char *) "self",(char *) "show", NULL
47536 };
47537
47538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47540 if (!SWIG_IsOK(res1)) {
47541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47542 }
47543 arg1 = reinterpret_cast< wxSizer * >(argp1);
47544 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47545 if (!SWIG_IsOK(ecode2)) {
47546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47547 }
47548 arg2 = static_cast< bool >(val2);
47549 {
47550 PyThreadState* __tstate = wxPyBeginAllowThreads();
47551 (arg1)->ShowItems(arg2);
47552 wxPyEndAllowThreads(__tstate);
47553 if (PyErr_Occurred()) SWIG_fail;
47554 }
47555 resultobj = SWIG_Py_Void();
47556 return resultobj;
47557 fail:
47558 return NULL;
47559 }
47560
47561
47562 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47563 PyObject *obj;
47564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47565 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47566 return SWIG_Py_Void();
47567 }
47568
47569 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47570 PyObject *resultobj = 0;
47571 wxPySizer *result = 0 ;
47572
47573 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47574 {
47575 PyThreadState* __tstate = wxPyBeginAllowThreads();
47576 result = (wxPySizer *)new wxPySizer();
47577 wxPyEndAllowThreads(__tstate);
47578 if (PyErr_Occurred()) SWIG_fail;
47579 }
47580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47581 return resultobj;
47582 fail:
47583 return NULL;
47584 }
47585
47586
47587 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47588 PyObject *resultobj = 0;
47589 wxPySizer *arg1 = (wxPySizer *) 0 ;
47590 PyObject *arg2 = (PyObject *) 0 ;
47591 PyObject *arg3 = (PyObject *) 0 ;
47592 void *argp1 = 0 ;
47593 int res1 = 0 ;
47594 PyObject * obj0 = 0 ;
47595 PyObject * obj1 = 0 ;
47596 PyObject * obj2 = 0 ;
47597 char * kwnames[] = {
47598 (char *) "self",(char *) "self",(char *) "_class", NULL
47599 };
47600
47601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47603 if (!SWIG_IsOK(res1)) {
47604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47605 }
47606 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47607 arg2 = obj1;
47608 arg3 = obj2;
47609 {
47610 PyThreadState* __tstate = wxPyBeginAllowThreads();
47611 (arg1)->_setCallbackInfo(arg2,arg3);
47612 wxPyEndAllowThreads(__tstate);
47613 if (PyErr_Occurred()) SWIG_fail;
47614 }
47615 resultobj = SWIG_Py_Void();
47616 return resultobj;
47617 fail:
47618 return NULL;
47619 }
47620
47621
47622 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47623 PyObject *obj;
47624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47625 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47626 return SWIG_Py_Void();
47627 }
47628
47629 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47630 return SWIG_Python_InitShadowInstance(args);
47631 }
47632
47633 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47634 PyObject *resultobj = 0;
47635 int arg1 = (int) wxHORIZONTAL ;
47636 wxBoxSizer *result = 0 ;
47637 int val1 ;
47638 int ecode1 = 0 ;
47639 PyObject * obj0 = 0 ;
47640 char * kwnames[] = {
47641 (char *) "orient", NULL
47642 };
47643
47644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47645 if (obj0) {
47646 ecode1 = SWIG_AsVal_int(obj0, &val1);
47647 if (!SWIG_IsOK(ecode1)) {
47648 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47649 }
47650 arg1 = static_cast< int >(val1);
47651 }
47652 {
47653 PyThreadState* __tstate = wxPyBeginAllowThreads();
47654 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47655 wxPyEndAllowThreads(__tstate);
47656 if (PyErr_Occurred()) SWIG_fail;
47657 }
47658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47659 return resultobj;
47660 fail:
47661 return NULL;
47662 }
47663
47664
47665 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47666 PyObject *resultobj = 0;
47667 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47668 int result;
47669 void *argp1 = 0 ;
47670 int res1 = 0 ;
47671 PyObject *swig_obj[1] ;
47672
47673 if (!args) SWIG_fail;
47674 swig_obj[0] = args;
47675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47676 if (!SWIG_IsOK(res1)) {
47677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47678 }
47679 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47680 {
47681 PyThreadState* __tstate = wxPyBeginAllowThreads();
47682 result = (int)(arg1)->GetOrientation();
47683 wxPyEndAllowThreads(__tstate);
47684 if (PyErr_Occurred()) SWIG_fail;
47685 }
47686 resultobj = SWIG_From_int(static_cast< int >(result));
47687 return resultobj;
47688 fail:
47689 return NULL;
47690 }
47691
47692
47693 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47694 PyObject *resultobj = 0;
47695 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47696 int arg2 ;
47697 void *argp1 = 0 ;
47698 int res1 = 0 ;
47699 int val2 ;
47700 int ecode2 = 0 ;
47701 PyObject * obj0 = 0 ;
47702 PyObject * obj1 = 0 ;
47703 char * kwnames[] = {
47704 (char *) "self",(char *) "orient", NULL
47705 };
47706
47707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47709 if (!SWIG_IsOK(res1)) {
47710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47711 }
47712 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47713 ecode2 = SWIG_AsVal_int(obj1, &val2);
47714 if (!SWIG_IsOK(ecode2)) {
47715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47716 }
47717 arg2 = static_cast< int >(val2);
47718 {
47719 PyThreadState* __tstate = wxPyBeginAllowThreads();
47720 (arg1)->SetOrientation(arg2);
47721 wxPyEndAllowThreads(__tstate);
47722 if (PyErr_Occurred()) SWIG_fail;
47723 }
47724 resultobj = SWIG_Py_Void();
47725 return resultobj;
47726 fail:
47727 return NULL;
47728 }
47729
47730
47731 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47732 PyObject *obj;
47733 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47734 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47735 return SWIG_Py_Void();
47736 }
47737
47738 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47739 return SWIG_Python_InitShadowInstance(args);
47740 }
47741
47742 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47743 PyObject *resultobj = 0;
47744 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47745 int arg2 = (int) wxHORIZONTAL ;
47746 wxStaticBoxSizer *result = 0 ;
47747 void *argp1 = 0 ;
47748 int res1 = 0 ;
47749 int val2 ;
47750 int ecode2 = 0 ;
47751 PyObject * obj0 = 0 ;
47752 PyObject * obj1 = 0 ;
47753 char * kwnames[] = {
47754 (char *) "box",(char *) "orient", NULL
47755 };
47756
47757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47759 if (!SWIG_IsOK(res1)) {
47760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47761 }
47762 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47763 if (obj1) {
47764 ecode2 = SWIG_AsVal_int(obj1, &val2);
47765 if (!SWIG_IsOK(ecode2)) {
47766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47767 }
47768 arg2 = static_cast< int >(val2);
47769 }
47770 {
47771 PyThreadState* __tstate = wxPyBeginAllowThreads();
47772 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47773 wxPyEndAllowThreads(__tstate);
47774 if (PyErr_Occurred()) SWIG_fail;
47775 }
47776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47777 return resultobj;
47778 fail:
47779 return NULL;
47780 }
47781
47782
47783 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47784 PyObject *resultobj = 0;
47785 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47786 wxStaticBox *result = 0 ;
47787 void *argp1 = 0 ;
47788 int res1 = 0 ;
47789 PyObject *swig_obj[1] ;
47790
47791 if (!args) SWIG_fail;
47792 swig_obj[0] = args;
47793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47794 if (!SWIG_IsOK(res1)) {
47795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47796 }
47797 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47798 {
47799 PyThreadState* __tstate = wxPyBeginAllowThreads();
47800 result = (wxStaticBox *)(arg1)->GetStaticBox();
47801 wxPyEndAllowThreads(__tstate);
47802 if (PyErr_Occurred()) SWIG_fail;
47803 }
47804 {
47805 resultobj = wxPyMake_wxObject(result, (bool)0);
47806 }
47807 return resultobj;
47808 fail:
47809 return NULL;
47810 }
47811
47812
47813 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47814 PyObject *obj;
47815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47816 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47817 return SWIG_Py_Void();
47818 }
47819
47820 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47821 return SWIG_Python_InitShadowInstance(args);
47822 }
47823
47824 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47825 PyObject *resultobj = 0;
47826 int arg1 = (int) 1 ;
47827 int arg2 = (int) 0 ;
47828 int arg3 = (int) 0 ;
47829 int arg4 = (int) 0 ;
47830 wxGridSizer *result = 0 ;
47831 int val1 ;
47832 int ecode1 = 0 ;
47833 int val2 ;
47834 int ecode2 = 0 ;
47835 int val3 ;
47836 int ecode3 = 0 ;
47837 int val4 ;
47838 int ecode4 = 0 ;
47839 PyObject * obj0 = 0 ;
47840 PyObject * obj1 = 0 ;
47841 PyObject * obj2 = 0 ;
47842 PyObject * obj3 = 0 ;
47843 char * kwnames[] = {
47844 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47845 };
47846
47847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47848 if (obj0) {
47849 ecode1 = SWIG_AsVal_int(obj0, &val1);
47850 if (!SWIG_IsOK(ecode1)) {
47851 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47852 }
47853 arg1 = static_cast< int >(val1);
47854 }
47855 if (obj1) {
47856 ecode2 = SWIG_AsVal_int(obj1, &val2);
47857 if (!SWIG_IsOK(ecode2)) {
47858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47859 }
47860 arg2 = static_cast< int >(val2);
47861 }
47862 if (obj2) {
47863 ecode3 = SWIG_AsVal_int(obj2, &val3);
47864 if (!SWIG_IsOK(ecode3)) {
47865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47866 }
47867 arg3 = static_cast< int >(val3);
47868 }
47869 if (obj3) {
47870 ecode4 = SWIG_AsVal_int(obj3, &val4);
47871 if (!SWIG_IsOK(ecode4)) {
47872 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47873 }
47874 arg4 = static_cast< int >(val4);
47875 }
47876 {
47877 PyThreadState* __tstate = wxPyBeginAllowThreads();
47878 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47879 wxPyEndAllowThreads(__tstate);
47880 if (PyErr_Occurred()) SWIG_fail;
47881 }
47882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47883 return resultobj;
47884 fail:
47885 return NULL;
47886 }
47887
47888
47889 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47890 PyObject *resultobj = 0;
47891 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47892 int arg2 ;
47893 void *argp1 = 0 ;
47894 int res1 = 0 ;
47895 int val2 ;
47896 int ecode2 = 0 ;
47897 PyObject * obj0 = 0 ;
47898 PyObject * obj1 = 0 ;
47899 char * kwnames[] = {
47900 (char *) "self",(char *) "cols", NULL
47901 };
47902
47903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47905 if (!SWIG_IsOK(res1)) {
47906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47907 }
47908 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47909 ecode2 = SWIG_AsVal_int(obj1, &val2);
47910 if (!SWIG_IsOK(ecode2)) {
47911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47912 }
47913 arg2 = static_cast< int >(val2);
47914 {
47915 PyThreadState* __tstate = wxPyBeginAllowThreads();
47916 (arg1)->SetCols(arg2);
47917 wxPyEndAllowThreads(__tstate);
47918 if (PyErr_Occurred()) SWIG_fail;
47919 }
47920 resultobj = SWIG_Py_Void();
47921 return resultobj;
47922 fail:
47923 return NULL;
47924 }
47925
47926
47927 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47928 PyObject *resultobj = 0;
47929 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47930 int arg2 ;
47931 void *argp1 = 0 ;
47932 int res1 = 0 ;
47933 int val2 ;
47934 int ecode2 = 0 ;
47935 PyObject * obj0 = 0 ;
47936 PyObject * obj1 = 0 ;
47937 char * kwnames[] = {
47938 (char *) "self",(char *) "rows", NULL
47939 };
47940
47941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47943 if (!SWIG_IsOK(res1)) {
47944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47945 }
47946 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47947 ecode2 = SWIG_AsVal_int(obj1, &val2);
47948 if (!SWIG_IsOK(ecode2)) {
47949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47950 }
47951 arg2 = static_cast< int >(val2);
47952 {
47953 PyThreadState* __tstate = wxPyBeginAllowThreads();
47954 (arg1)->SetRows(arg2);
47955 wxPyEndAllowThreads(__tstate);
47956 if (PyErr_Occurred()) SWIG_fail;
47957 }
47958 resultobj = SWIG_Py_Void();
47959 return resultobj;
47960 fail:
47961 return NULL;
47962 }
47963
47964
47965 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47966 PyObject *resultobj = 0;
47967 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47968 int arg2 ;
47969 void *argp1 = 0 ;
47970 int res1 = 0 ;
47971 int val2 ;
47972 int ecode2 = 0 ;
47973 PyObject * obj0 = 0 ;
47974 PyObject * obj1 = 0 ;
47975 char * kwnames[] = {
47976 (char *) "self",(char *) "gap", NULL
47977 };
47978
47979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47981 if (!SWIG_IsOK(res1)) {
47982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47983 }
47984 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47985 ecode2 = SWIG_AsVal_int(obj1, &val2);
47986 if (!SWIG_IsOK(ecode2)) {
47987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47988 }
47989 arg2 = static_cast< int >(val2);
47990 {
47991 PyThreadState* __tstate = wxPyBeginAllowThreads();
47992 (arg1)->SetVGap(arg2);
47993 wxPyEndAllowThreads(__tstate);
47994 if (PyErr_Occurred()) SWIG_fail;
47995 }
47996 resultobj = SWIG_Py_Void();
47997 return resultobj;
47998 fail:
47999 return NULL;
48000 }
48001
48002
48003 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48004 PyObject *resultobj = 0;
48005 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48006 int arg2 ;
48007 void *argp1 = 0 ;
48008 int res1 = 0 ;
48009 int val2 ;
48010 int ecode2 = 0 ;
48011 PyObject * obj0 = 0 ;
48012 PyObject * obj1 = 0 ;
48013 char * kwnames[] = {
48014 (char *) "self",(char *) "gap", NULL
48015 };
48016
48017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48019 if (!SWIG_IsOK(res1)) {
48020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48021 }
48022 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48023 ecode2 = SWIG_AsVal_int(obj1, &val2);
48024 if (!SWIG_IsOK(ecode2)) {
48025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48026 }
48027 arg2 = static_cast< int >(val2);
48028 {
48029 PyThreadState* __tstate = wxPyBeginAllowThreads();
48030 (arg1)->SetHGap(arg2);
48031 wxPyEndAllowThreads(__tstate);
48032 if (PyErr_Occurred()) SWIG_fail;
48033 }
48034 resultobj = SWIG_Py_Void();
48035 return resultobj;
48036 fail:
48037 return NULL;
48038 }
48039
48040
48041 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48042 PyObject *resultobj = 0;
48043 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48044 int result;
48045 void *argp1 = 0 ;
48046 int res1 = 0 ;
48047 PyObject *swig_obj[1] ;
48048
48049 if (!args) SWIG_fail;
48050 swig_obj[0] = args;
48051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48052 if (!SWIG_IsOK(res1)) {
48053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48054 }
48055 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48056 {
48057 PyThreadState* __tstate = wxPyBeginAllowThreads();
48058 result = (int)(arg1)->GetCols();
48059 wxPyEndAllowThreads(__tstate);
48060 if (PyErr_Occurred()) SWIG_fail;
48061 }
48062 resultobj = SWIG_From_int(static_cast< int >(result));
48063 return resultobj;
48064 fail:
48065 return NULL;
48066 }
48067
48068
48069 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48070 PyObject *resultobj = 0;
48071 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48072 int result;
48073 void *argp1 = 0 ;
48074 int res1 = 0 ;
48075 PyObject *swig_obj[1] ;
48076
48077 if (!args) SWIG_fail;
48078 swig_obj[0] = args;
48079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48080 if (!SWIG_IsOK(res1)) {
48081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48082 }
48083 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48084 {
48085 PyThreadState* __tstate = wxPyBeginAllowThreads();
48086 result = (int)(arg1)->GetRows();
48087 wxPyEndAllowThreads(__tstate);
48088 if (PyErr_Occurred()) SWIG_fail;
48089 }
48090 resultobj = SWIG_From_int(static_cast< int >(result));
48091 return resultobj;
48092 fail:
48093 return NULL;
48094 }
48095
48096
48097 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48098 PyObject *resultobj = 0;
48099 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48100 int result;
48101 void *argp1 = 0 ;
48102 int res1 = 0 ;
48103 PyObject *swig_obj[1] ;
48104
48105 if (!args) SWIG_fail;
48106 swig_obj[0] = args;
48107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48108 if (!SWIG_IsOK(res1)) {
48109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48110 }
48111 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48112 {
48113 PyThreadState* __tstate = wxPyBeginAllowThreads();
48114 result = (int)(arg1)->GetVGap();
48115 wxPyEndAllowThreads(__tstate);
48116 if (PyErr_Occurred()) SWIG_fail;
48117 }
48118 resultobj = SWIG_From_int(static_cast< int >(result));
48119 return resultobj;
48120 fail:
48121 return NULL;
48122 }
48123
48124
48125 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48126 PyObject *resultobj = 0;
48127 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48128 int result;
48129 void *argp1 = 0 ;
48130 int res1 = 0 ;
48131 PyObject *swig_obj[1] ;
48132
48133 if (!args) SWIG_fail;
48134 swig_obj[0] = args;
48135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48136 if (!SWIG_IsOK(res1)) {
48137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48138 }
48139 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48140 {
48141 PyThreadState* __tstate = wxPyBeginAllowThreads();
48142 result = (int)(arg1)->GetHGap();
48143 wxPyEndAllowThreads(__tstate);
48144 if (PyErr_Occurred()) SWIG_fail;
48145 }
48146 resultobj = SWIG_From_int(static_cast< int >(result));
48147 return resultobj;
48148 fail:
48149 return NULL;
48150 }
48151
48152
48153 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48154 PyObject *obj;
48155 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48156 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48157 return SWIG_Py_Void();
48158 }
48159
48160 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48161 return SWIG_Python_InitShadowInstance(args);
48162 }
48163
48164 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48165 PyObject *resultobj = 0;
48166 int arg1 = (int) 1 ;
48167 int arg2 = (int) 0 ;
48168 int arg3 = (int) 0 ;
48169 int arg4 = (int) 0 ;
48170 wxFlexGridSizer *result = 0 ;
48171 int val1 ;
48172 int ecode1 = 0 ;
48173 int val2 ;
48174 int ecode2 = 0 ;
48175 int val3 ;
48176 int ecode3 = 0 ;
48177 int val4 ;
48178 int ecode4 = 0 ;
48179 PyObject * obj0 = 0 ;
48180 PyObject * obj1 = 0 ;
48181 PyObject * obj2 = 0 ;
48182 PyObject * obj3 = 0 ;
48183 char * kwnames[] = {
48184 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48185 };
48186
48187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48188 if (obj0) {
48189 ecode1 = SWIG_AsVal_int(obj0, &val1);
48190 if (!SWIG_IsOK(ecode1)) {
48191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48192 }
48193 arg1 = static_cast< int >(val1);
48194 }
48195 if (obj1) {
48196 ecode2 = SWIG_AsVal_int(obj1, &val2);
48197 if (!SWIG_IsOK(ecode2)) {
48198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48199 }
48200 arg2 = static_cast< int >(val2);
48201 }
48202 if (obj2) {
48203 ecode3 = SWIG_AsVal_int(obj2, &val3);
48204 if (!SWIG_IsOK(ecode3)) {
48205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48206 }
48207 arg3 = static_cast< int >(val3);
48208 }
48209 if (obj3) {
48210 ecode4 = SWIG_AsVal_int(obj3, &val4);
48211 if (!SWIG_IsOK(ecode4)) {
48212 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48213 }
48214 arg4 = static_cast< int >(val4);
48215 }
48216 {
48217 PyThreadState* __tstate = wxPyBeginAllowThreads();
48218 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48219 wxPyEndAllowThreads(__tstate);
48220 if (PyErr_Occurred()) SWIG_fail;
48221 }
48222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48223 return resultobj;
48224 fail:
48225 return NULL;
48226 }
48227
48228
48229 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48230 PyObject *resultobj = 0;
48231 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48232 size_t arg2 ;
48233 int arg3 = (int) 0 ;
48234 void *argp1 = 0 ;
48235 int res1 = 0 ;
48236 size_t val2 ;
48237 int ecode2 = 0 ;
48238 int val3 ;
48239 int ecode3 = 0 ;
48240 PyObject * obj0 = 0 ;
48241 PyObject * obj1 = 0 ;
48242 PyObject * obj2 = 0 ;
48243 char * kwnames[] = {
48244 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48245 };
48246
48247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48249 if (!SWIG_IsOK(res1)) {
48250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48251 }
48252 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48253 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48254 if (!SWIG_IsOK(ecode2)) {
48255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48256 }
48257 arg2 = static_cast< size_t >(val2);
48258 if (obj2) {
48259 ecode3 = SWIG_AsVal_int(obj2, &val3);
48260 if (!SWIG_IsOK(ecode3)) {
48261 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48262 }
48263 arg3 = static_cast< int >(val3);
48264 }
48265 {
48266 PyThreadState* __tstate = wxPyBeginAllowThreads();
48267 (arg1)->AddGrowableRow(arg2,arg3);
48268 wxPyEndAllowThreads(__tstate);
48269 if (PyErr_Occurred()) SWIG_fail;
48270 }
48271 resultobj = SWIG_Py_Void();
48272 return resultobj;
48273 fail:
48274 return NULL;
48275 }
48276
48277
48278 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48279 PyObject *resultobj = 0;
48280 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48281 size_t arg2 ;
48282 void *argp1 = 0 ;
48283 int res1 = 0 ;
48284 size_t val2 ;
48285 int ecode2 = 0 ;
48286 PyObject * obj0 = 0 ;
48287 PyObject * obj1 = 0 ;
48288 char * kwnames[] = {
48289 (char *) "self",(char *) "idx", NULL
48290 };
48291
48292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48294 if (!SWIG_IsOK(res1)) {
48295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48296 }
48297 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48298 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48299 if (!SWIG_IsOK(ecode2)) {
48300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48301 }
48302 arg2 = static_cast< size_t >(val2);
48303 {
48304 PyThreadState* __tstate = wxPyBeginAllowThreads();
48305 (arg1)->RemoveGrowableRow(arg2);
48306 wxPyEndAllowThreads(__tstate);
48307 if (PyErr_Occurred()) SWIG_fail;
48308 }
48309 resultobj = SWIG_Py_Void();
48310 return resultobj;
48311 fail:
48312 return NULL;
48313 }
48314
48315
48316 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48317 PyObject *resultobj = 0;
48318 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48319 size_t arg2 ;
48320 int arg3 = (int) 0 ;
48321 void *argp1 = 0 ;
48322 int res1 = 0 ;
48323 size_t val2 ;
48324 int ecode2 = 0 ;
48325 int val3 ;
48326 int ecode3 = 0 ;
48327 PyObject * obj0 = 0 ;
48328 PyObject * obj1 = 0 ;
48329 PyObject * obj2 = 0 ;
48330 char * kwnames[] = {
48331 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48332 };
48333
48334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48336 if (!SWIG_IsOK(res1)) {
48337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48338 }
48339 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48340 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48341 if (!SWIG_IsOK(ecode2)) {
48342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48343 }
48344 arg2 = static_cast< size_t >(val2);
48345 if (obj2) {
48346 ecode3 = SWIG_AsVal_int(obj2, &val3);
48347 if (!SWIG_IsOK(ecode3)) {
48348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48349 }
48350 arg3 = static_cast< int >(val3);
48351 }
48352 {
48353 PyThreadState* __tstate = wxPyBeginAllowThreads();
48354 (arg1)->AddGrowableCol(arg2,arg3);
48355 wxPyEndAllowThreads(__tstate);
48356 if (PyErr_Occurred()) SWIG_fail;
48357 }
48358 resultobj = SWIG_Py_Void();
48359 return resultobj;
48360 fail:
48361 return NULL;
48362 }
48363
48364
48365 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48366 PyObject *resultobj = 0;
48367 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48368 size_t arg2 ;
48369 void *argp1 = 0 ;
48370 int res1 = 0 ;
48371 size_t val2 ;
48372 int ecode2 = 0 ;
48373 PyObject * obj0 = 0 ;
48374 PyObject * obj1 = 0 ;
48375 char * kwnames[] = {
48376 (char *) "self",(char *) "idx", NULL
48377 };
48378
48379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48381 if (!SWIG_IsOK(res1)) {
48382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48383 }
48384 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48385 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48386 if (!SWIG_IsOK(ecode2)) {
48387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48388 }
48389 arg2 = static_cast< size_t >(val2);
48390 {
48391 PyThreadState* __tstate = wxPyBeginAllowThreads();
48392 (arg1)->RemoveGrowableCol(arg2);
48393 wxPyEndAllowThreads(__tstate);
48394 if (PyErr_Occurred()) SWIG_fail;
48395 }
48396 resultobj = SWIG_Py_Void();
48397 return resultobj;
48398 fail:
48399 return NULL;
48400 }
48401
48402
48403 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48404 PyObject *resultobj = 0;
48405 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48406 int arg2 ;
48407 void *argp1 = 0 ;
48408 int res1 = 0 ;
48409 int val2 ;
48410 int ecode2 = 0 ;
48411 PyObject * obj0 = 0 ;
48412 PyObject * obj1 = 0 ;
48413 char * kwnames[] = {
48414 (char *) "self",(char *) "direction", NULL
48415 };
48416
48417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48419 if (!SWIG_IsOK(res1)) {
48420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48421 }
48422 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48423 ecode2 = SWIG_AsVal_int(obj1, &val2);
48424 if (!SWIG_IsOK(ecode2)) {
48425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48426 }
48427 arg2 = static_cast< int >(val2);
48428 {
48429 PyThreadState* __tstate = wxPyBeginAllowThreads();
48430 (arg1)->SetFlexibleDirection(arg2);
48431 wxPyEndAllowThreads(__tstate);
48432 if (PyErr_Occurred()) SWIG_fail;
48433 }
48434 resultobj = SWIG_Py_Void();
48435 return resultobj;
48436 fail:
48437 return NULL;
48438 }
48439
48440
48441 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48442 PyObject *resultobj = 0;
48443 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48444 int result;
48445 void *argp1 = 0 ;
48446 int res1 = 0 ;
48447 PyObject *swig_obj[1] ;
48448
48449 if (!args) SWIG_fail;
48450 swig_obj[0] = args;
48451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48452 if (!SWIG_IsOK(res1)) {
48453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48454 }
48455 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48456 {
48457 PyThreadState* __tstate = wxPyBeginAllowThreads();
48458 result = (int)(arg1)->GetFlexibleDirection();
48459 wxPyEndAllowThreads(__tstate);
48460 if (PyErr_Occurred()) SWIG_fail;
48461 }
48462 resultobj = SWIG_From_int(static_cast< int >(result));
48463 return resultobj;
48464 fail:
48465 return NULL;
48466 }
48467
48468
48469 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48470 PyObject *resultobj = 0;
48471 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48472 wxFlexSizerGrowMode arg2 ;
48473 void *argp1 = 0 ;
48474 int res1 = 0 ;
48475 int val2 ;
48476 int ecode2 = 0 ;
48477 PyObject * obj0 = 0 ;
48478 PyObject * obj1 = 0 ;
48479 char * kwnames[] = {
48480 (char *) "self",(char *) "mode", NULL
48481 };
48482
48483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48485 if (!SWIG_IsOK(res1)) {
48486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48487 }
48488 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48489 ecode2 = SWIG_AsVal_int(obj1, &val2);
48490 if (!SWIG_IsOK(ecode2)) {
48491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48492 }
48493 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48494 {
48495 PyThreadState* __tstate = wxPyBeginAllowThreads();
48496 (arg1)->SetNonFlexibleGrowMode(arg2);
48497 wxPyEndAllowThreads(__tstate);
48498 if (PyErr_Occurred()) SWIG_fail;
48499 }
48500 resultobj = SWIG_Py_Void();
48501 return resultobj;
48502 fail:
48503 return NULL;
48504 }
48505
48506
48507 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48508 PyObject *resultobj = 0;
48509 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48510 wxFlexSizerGrowMode result;
48511 void *argp1 = 0 ;
48512 int res1 = 0 ;
48513 PyObject *swig_obj[1] ;
48514
48515 if (!args) SWIG_fail;
48516 swig_obj[0] = args;
48517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48518 if (!SWIG_IsOK(res1)) {
48519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48520 }
48521 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48522 {
48523 PyThreadState* __tstate = wxPyBeginAllowThreads();
48524 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48525 wxPyEndAllowThreads(__tstate);
48526 if (PyErr_Occurred()) SWIG_fail;
48527 }
48528 resultobj = SWIG_From_int(static_cast< int >(result));
48529 return resultobj;
48530 fail:
48531 return NULL;
48532 }
48533
48534
48535 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48536 PyObject *resultobj = 0;
48537 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48538 wxArrayInt *result = 0 ;
48539 void *argp1 = 0 ;
48540 int res1 = 0 ;
48541 PyObject *swig_obj[1] ;
48542
48543 if (!args) SWIG_fail;
48544 swig_obj[0] = args;
48545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48546 if (!SWIG_IsOK(res1)) {
48547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48548 }
48549 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48550 {
48551 PyThreadState* __tstate = wxPyBeginAllowThreads();
48552 {
48553 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48554 result = (wxArrayInt *) &_result_ref;
48555 }
48556 wxPyEndAllowThreads(__tstate);
48557 if (PyErr_Occurred()) SWIG_fail;
48558 }
48559 {
48560 resultobj = PyList_New(0);
48561 size_t idx;
48562 for (idx = 0; idx < result->GetCount(); idx += 1) {
48563 PyObject* val = PyInt_FromLong( result->Item(idx) );
48564 PyList_Append(resultobj, val);
48565 Py_DECREF(val);
48566 }
48567 }
48568 return resultobj;
48569 fail:
48570 return NULL;
48571 }
48572
48573
48574 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48575 PyObject *resultobj = 0;
48576 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48577 wxArrayInt *result = 0 ;
48578 void *argp1 = 0 ;
48579 int res1 = 0 ;
48580 PyObject *swig_obj[1] ;
48581
48582 if (!args) SWIG_fail;
48583 swig_obj[0] = args;
48584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48585 if (!SWIG_IsOK(res1)) {
48586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48587 }
48588 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48589 {
48590 PyThreadState* __tstate = wxPyBeginAllowThreads();
48591 {
48592 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48593 result = (wxArrayInt *) &_result_ref;
48594 }
48595 wxPyEndAllowThreads(__tstate);
48596 if (PyErr_Occurred()) SWIG_fail;
48597 }
48598 {
48599 resultobj = PyList_New(0);
48600 size_t idx;
48601 for (idx = 0; idx < result->GetCount(); idx += 1) {
48602 PyObject* val = PyInt_FromLong( result->Item(idx) );
48603 PyList_Append(resultobj, val);
48604 Py_DECREF(val);
48605 }
48606 }
48607 return resultobj;
48608 fail:
48609 return NULL;
48610 }
48611
48612
48613 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48614 PyObject *obj;
48615 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48616 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48617 return SWIG_Py_Void();
48618 }
48619
48620 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48621 return SWIG_Python_InitShadowInstance(args);
48622 }
48623
48624 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48625 PyObject *resultobj = 0;
48626 wxStdDialogButtonSizer *result = 0 ;
48627
48628 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48629 {
48630 PyThreadState* __tstate = wxPyBeginAllowThreads();
48631 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48632 wxPyEndAllowThreads(__tstate);
48633 if (PyErr_Occurred()) SWIG_fail;
48634 }
48635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48636 return resultobj;
48637 fail:
48638 return NULL;
48639 }
48640
48641
48642 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48643 PyObject *resultobj = 0;
48644 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48645 wxButton *arg2 = (wxButton *) 0 ;
48646 void *argp1 = 0 ;
48647 int res1 = 0 ;
48648 void *argp2 = 0 ;
48649 int res2 = 0 ;
48650 PyObject * obj0 = 0 ;
48651 PyObject * obj1 = 0 ;
48652 char * kwnames[] = {
48653 (char *) "self",(char *) "button", NULL
48654 };
48655
48656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48658 if (!SWIG_IsOK(res1)) {
48659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48660 }
48661 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48662 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48663 if (!SWIG_IsOK(res2)) {
48664 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48665 }
48666 arg2 = reinterpret_cast< wxButton * >(argp2);
48667 {
48668 PyThreadState* __tstate = wxPyBeginAllowThreads();
48669 (arg1)->AddButton(arg2);
48670 wxPyEndAllowThreads(__tstate);
48671 if (PyErr_Occurred()) SWIG_fail;
48672 }
48673 resultobj = SWIG_Py_Void();
48674 return resultobj;
48675 fail:
48676 return NULL;
48677 }
48678
48679
48680 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48681 PyObject *resultobj = 0;
48682 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48683 void *argp1 = 0 ;
48684 int res1 = 0 ;
48685 PyObject *swig_obj[1] ;
48686
48687 if (!args) SWIG_fail;
48688 swig_obj[0] = args;
48689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48690 if (!SWIG_IsOK(res1)) {
48691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48692 }
48693 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48694 {
48695 PyThreadState* __tstate = wxPyBeginAllowThreads();
48696 (arg1)->Realize();
48697 wxPyEndAllowThreads(__tstate);
48698 if (PyErr_Occurred()) SWIG_fail;
48699 }
48700 resultobj = SWIG_Py_Void();
48701 return resultobj;
48702 fail:
48703 return NULL;
48704 }
48705
48706
48707 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48708 PyObject *resultobj = 0;
48709 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48710 wxButton *arg2 = (wxButton *) 0 ;
48711 void *argp1 = 0 ;
48712 int res1 = 0 ;
48713 void *argp2 = 0 ;
48714 int res2 = 0 ;
48715 PyObject * obj0 = 0 ;
48716 PyObject * obj1 = 0 ;
48717 char * kwnames[] = {
48718 (char *) "self",(char *) "button", NULL
48719 };
48720
48721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48723 if (!SWIG_IsOK(res1)) {
48724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48725 }
48726 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48727 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48728 if (!SWIG_IsOK(res2)) {
48729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48730 }
48731 arg2 = reinterpret_cast< wxButton * >(argp2);
48732 {
48733 PyThreadState* __tstate = wxPyBeginAllowThreads();
48734 (arg1)->SetAffirmativeButton(arg2);
48735 wxPyEndAllowThreads(__tstate);
48736 if (PyErr_Occurred()) SWIG_fail;
48737 }
48738 resultobj = SWIG_Py_Void();
48739 return resultobj;
48740 fail:
48741 return NULL;
48742 }
48743
48744
48745 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48746 PyObject *resultobj = 0;
48747 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48748 wxButton *arg2 = (wxButton *) 0 ;
48749 void *argp1 = 0 ;
48750 int res1 = 0 ;
48751 void *argp2 = 0 ;
48752 int res2 = 0 ;
48753 PyObject * obj0 = 0 ;
48754 PyObject * obj1 = 0 ;
48755 char * kwnames[] = {
48756 (char *) "self",(char *) "button", NULL
48757 };
48758
48759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48761 if (!SWIG_IsOK(res1)) {
48762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48763 }
48764 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48765 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48766 if (!SWIG_IsOK(res2)) {
48767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48768 }
48769 arg2 = reinterpret_cast< wxButton * >(argp2);
48770 {
48771 PyThreadState* __tstate = wxPyBeginAllowThreads();
48772 (arg1)->SetNegativeButton(arg2);
48773 wxPyEndAllowThreads(__tstate);
48774 if (PyErr_Occurred()) SWIG_fail;
48775 }
48776 resultobj = SWIG_Py_Void();
48777 return resultobj;
48778 fail:
48779 return NULL;
48780 }
48781
48782
48783 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48784 PyObject *resultobj = 0;
48785 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48786 wxButton *arg2 = (wxButton *) 0 ;
48787 void *argp1 = 0 ;
48788 int res1 = 0 ;
48789 void *argp2 = 0 ;
48790 int res2 = 0 ;
48791 PyObject * obj0 = 0 ;
48792 PyObject * obj1 = 0 ;
48793 char * kwnames[] = {
48794 (char *) "self",(char *) "button", NULL
48795 };
48796
48797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48799 if (!SWIG_IsOK(res1)) {
48800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48801 }
48802 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48803 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48804 if (!SWIG_IsOK(res2)) {
48805 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48806 }
48807 arg2 = reinterpret_cast< wxButton * >(argp2);
48808 {
48809 PyThreadState* __tstate = wxPyBeginAllowThreads();
48810 (arg1)->SetCancelButton(arg2);
48811 wxPyEndAllowThreads(__tstate);
48812 if (PyErr_Occurred()) SWIG_fail;
48813 }
48814 resultobj = SWIG_Py_Void();
48815 return resultobj;
48816 fail:
48817 return NULL;
48818 }
48819
48820
48821 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48822 PyObject *resultobj = 0;
48823 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48824 wxButton *result = 0 ;
48825 void *argp1 = 0 ;
48826 int res1 = 0 ;
48827 PyObject *swig_obj[1] ;
48828
48829 if (!args) SWIG_fail;
48830 swig_obj[0] = args;
48831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48832 if (!SWIG_IsOK(res1)) {
48833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48834 }
48835 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48836 {
48837 PyThreadState* __tstate = wxPyBeginAllowThreads();
48838 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48839 wxPyEndAllowThreads(__tstate);
48840 if (PyErr_Occurred()) SWIG_fail;
48841 }
48842 {
48843 resultobj = wxPyMake_wxObject(result, (bool)0);
48844 }
48845 return resultobj;
48846 fail:
48847 return NULL;
48848 }
48849
48850
48851 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48852 PyObject *resultobj = 0;
48853 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48854 wxButton *result = 0 ;
48855 void *argp1 = 0 ;
48856 int res1 = 0 ;
48857 PyObject *swig_obj[1] ;
48858
48859 if (!args) SWIG_fail;
48860 swig_obj[0] = args;
48861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48862 if (!SWIG_IsOK(res1)) {
48863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48864 }
48865 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48866 {
48867 PyThreadState* __tstate = wxPyBeginAllowThreads();
48868 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48869 wxPyEndAllowThreads(__tstate);
48870 if (PyErr_Occurred()) SWIG_fail;
48871 }
48872 {
48873 resultobj = wxPyMake_wxObject(result, (bool)0);
48874 }
48875 return resultobj;
48876 fail:
48877 return NULL;
48878 }
48879
48880
48881 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48882 PyObject *resultobj = 0;
48883 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48884 wxButton *result = 0 ;
48885 void *argp1 = 0 ;
48886 int res1 = 0 ;
48887 PyObject *swig_obj[1] ;
48888
48889 if (!args) SWIG_fail;
48890 swig_obj[0] = args;
48891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48892 if (!SWIG_IsOK(res1)) {
48893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48894 }
48895 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48896 {
48897 PyThreadState* __tstate = wxPyBeginAllowThreads();
48898 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48899 wxPyEndAllowThreads(__tstate);
48900 if (PyErr_Occurred()) SWIG_fail;
48901 }
48902 {
48903 resultobj = wxPyMake_wxObject(result, (bool)0);
48904 }
48905 return resultobj;
48906 fail:
48907 return NULL;
48908 }
48909
48910
48911 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48912 PyObject *resultobj = 0;
48913 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48914 wxButton *result = 0 ;
48915 void *argp1 = 0 ;
48916 int res1 = 0 ;
48917 PyObject *swig_obj[1] ;
48918
48919 if (!args) SWIG_fail;
48920 swig_obj[0] = args;
48921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48922 if (!SWIG_IsOK(res1)) {
48923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48924 }
48925 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48926 {
48927 PyThreadState* __tstate = wxPyBeginAllowThreads();
48928 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48929 wxPyEndAllowThreads(__tstate);
48930 if (PyErr_Occurred()) SWIG_fail;
48931 }
48932 {
48933 resultobj = wxPyMake_wxObject(result, (bool)0);
48934 }
48935 return resultobj;
48936 fail:
48937 return NULL;
48938 }
48939
48940
48941 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48942 PyObject *resultobj = 0;
48943 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48944 wxButton *result = 0 ;
48945 void *argp1 = 0 ;
48946 int res1 = 0 ;
48947 PyObject *swig_obj[1] ;
48948
48949 if (!args) SWIG_fail;
48950 swig_obj[0] = args;
48951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48952 if (!SWIG_IsOK(res1)) {
48953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48954 }
48955 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48956 {
48957 PyThreadState* __tstate = wxPyBeginAllowThreads();
48958 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48959 wxPyEndAllowThreads(__tstate);
48960 if (PyErr_Occurred()) SWIG_fail;
48961 }
48962 {
48963 resultobj = wxPyMake_wxObject(result, (bool)0);
48964 }
48965 return resultobj;
48966 fail:
48967 return NULL;
48968 }
48969
48970
48971 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48972 PyObject *obj;
48973 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48974 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48975 return SWIG_Py_Void();
48976 }
48977
48978 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48979 return SWIG_Python_InitShadowInstance(args);
48980 }
48981
48982 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48983 PyObject *resultobj = 0;
48984 int arg1 = (int) 0 ;
48985 int arg2 = (int) 0 ;
48986 wxGBPosition *result = 0 ;
48987 int val1 ;
48988 int ecode1 = 0 ;
48989 int val2 ;
48990 int ecode2 = 0 ;
48991 PyObject * obj0 = 0 ;
48992 PyObject * obj1 = 0 ;
48993 char * kwnames[] = {
48994 (char *) "row",(char *) "col", NULL
48995 };
48996
48997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48998 if (obj0) {
48999 ecode1 = SWIG_AsVal_int(obj0, &val1);
49000 if (!SWIG_IsOK(ecode1)) {
49001 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49002 }
49003 arg1 = static_cast< int >(val1);
49004 }
49005 if (obj1) {
49006 ecode2 = SWIG_AsVal_int(obj1, &val2);
49007 if (!SWIG_IsOK(ecode2)) {
49008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49009 }
49010 arg2 = static_cast< int >(val2);
49011 }
49012 {
49013 PyThreadState* __tstate = wxPyBeginAllowThreads();
49014 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49015 wxPyEndAllowThreads(__tstate);
49016 if (PyErr_Occurred()) SWIG_fail;
49017 }
49018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49019 return resultobj;
49020 fail:
49021 return NULL;
49022 }
49023
49024
49025 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49026 PyObject *resultobj = 0;
49027 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49028 void *argp1 = 0 ;
49029 int res1 = 0 ;
49030 PyObject *swig_obj[1] ;
49031
49032 if (!args) SWIG_fail;
49033 swig_obj[0] = args;
49034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49035 if (!SWIG_IsOK(res1)) {
49036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49037 }
49038 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49039 {
49040 PyThreadState* __tstate = wxPyBeginAllowThreads();
49041 delete arg1;
49042
49043 wxPyEndAllowThreads(__tstate);
49044 if (PyErr_Occurred()) SWIG_fail;
49045 }
49046 resultobj = SWIG_Py_Void();
49047 return resultobj;
49048 fail:
49049 return NULL;
49050 }
49051
49052
49053 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49054 PyObject *resultobj = 0;
49055 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49056 int result;
49057 void *argp1 = 0 ;
49058 int res1 = 0 ;
49059 PyObject *swig_obj[1] ;
49060
49061 if (!args) SWIG_fail;
49062 swig_obj[0] = args;
49063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49064 if (!SWIG_IsOK(res1)) {
49065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49066 }
49067 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49068 {
49069 PyThreadState* __tstate = wxPyBeginAllowThreads();
49070 result = (int)((wxGBPosition const *)arg1)->GetRow();
49071 wxPyEndAllowThreads(__tstate);
49072 if (PyErr_Occurred()) SWIG_fail;
49073 }
49074 resultobj = SWIG_From_int(static_cast< int >(result));
49075 return resultobj;
49076 fail:
49077 return NULL;
49078 }
49079
49080
49081 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49082 PyObject *resultobj = 0;
49083 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49084 int result;
49085 void *argp1 = 0 ;
49086 int res1 = 0 ;
49087 PyObject *swig_obj[1] ;
49088
49089 if (!args) SWIG_fail;
49090 swig_obj[0] = args;
49091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49092 if (!SWIG_IsOK(res1)) {
49093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49094 }
49095 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49096 {
49097 PyThreadState* __tstate = wxPyBeginAllowThreads();
49098 result = (int)((wxGBPosition const *)arg1)->GetCol();
49099 wxPyEndAllowThreads(__tstate);
49100 if (PyErr_Occurred()) SWIG_fail;
49101 }
49102 resultobj = SWIG_From_int(static_cast< int >(result));
49103 return resultobj;
49104 fail:
49105 return NULL;
49106 }
49107
49108
49109 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49110 PyObject *resultobj = 0;
49111 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49112 int arg2 ;
49113 void *argp1 = 0 ;
49114 int res1 = 0 ;
49115 int val2 ;
49116 int ecode2 = 0 ;
49117 PyObject * obj0 = 0 ;
49118 PyObject * obj1 = 0 ;
49119 char * kwnames[] = {
49120 (char *) "self",(char *) "row", NULL
49121 };
49122
49123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49125 if (!SWIG_IsOK(res1)) {
49126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49127 }
49128 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49129 ecode2 = SWIG_AsVal_int(obj1, &val2);
49130 if (!SWIG_IsOK(ecode2)) {
49131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49132 }
49133 arg2 = static_cast< int >(val2);
49134 {
49135 PyThreadState* __tstate = wxPyBeginAllowThreads();
49136 (arg1)->SetRow(arg2);
49137 wxPyEndAllowThreads(__tstate);
49138 if (PyErr_Occurred()) SWIG_fail;
49139 }
49140 resultobj = SWIG_Py_Void();
49141 return resultobj;
49142 fail:
49143 return NULL;
49144 }
49145
49146
49147 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49148 PyObject *resultobj = 0;
49149 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49150 int arg2 ;
49151 void *argp1 = 0 ;
49152 int res1 = 0 ;
49153 int val2 ;
49154 int ecode2 = 0 ;
49155 PyObject * obj0 = 0 ;
49156 PyObject * obj1 = 0 ;
49157 char * kwnames[] = {
49158 (char *) "self",(char *) "col", NULL
49159 };
49160
49161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49163 if (!SWIG_IsOK(res1)) {
49164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49165 }
49166 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49167 ecode2 = SWIG_AsVal_int(obj1, &val2);
49168 if (!SWIG_IsOK(ecode2)) {
49169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49170 }
49171 arg2 = static_cast< int >(val2);
49172 {
49173 PyThreadState* __tstate = wxPyBeginAllowThreads();
49174 (arg1)->SetCol(arg2);
49175 wxPyEndAllowThreads(__tstate);
49176 if (PyErr_Occurred()) SWIG_fail;
49177 }
49178 resultobj = SWIG_Py_Void();
49179 return resultobj;
49180 fail:
49181 return NULL;
49182 }
49183
49184
49185 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49186 PyObject *resultobj = 0;
49187 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49188 PyObject *arg2 = (PyObject *) 0 ;
49189 bool result;
49190 void *argp1 = 0 ;
49191 int res1 = 0 ;
49192 PyObject * obj0 = 0 ;
49193 PyObject * obj1 = 0 ;
49194 char * kwnames[] = {
49195 (char *) "self",(char *) "other", NULL
49196 };
49197
49198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49200 if (!SWIG_IsOK(res1)) {
49201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49202 }
49203 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49204 arg2 = obj1;
49205 {
49206 result = (bool)wxGBPosition___eq__(arg1,arg2);
49207 if (PyErr_Occurred()) SWIG_fail;
49208 }
49209 {
49210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49211 }
49212 return resultobj;
49213 fail:
49214 return NULL;
49215 }
49216
49217
49218 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49219 PyObject *resultobj = 0;
49220 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49221 PyObject *arg2 = (PyObject *) 0 ;
49222 bool result;
49223 void *argp1 = 0 ;
49224 int res1 = 0 ;
49225 PyObject * obj0 = 0 ;
49226 PyObject * obj1 = 0 ;
49227 char * kwnames[] = {
49228 (char *) "self",(char *) "other", NULL
49229 };
49230
49231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49233 if (!SWIG_IsOK(res1)) {
49234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49235 }
49236 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49237 arg2 = obj1;
49238 {
49239 result = (bool)wxGBPosition___ne__(arg1,arg2);
49240 if (PyErr_Occurred()) SWIG_fail;
49241 }
49242 {
49243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49244 }
49245 return resultobj;
49246 fail:
49247 return NULL;
49248 }
49249
49250
49251 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49252 PyObject *resultobj = 0;
49253 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49254 int arg2 = (int) 0 ;
49255 int arg3 = (int) 0 ;
49256 void *argp1 = 0 ;
49257 int res1 = 0 ;
49258 int val2 ;
49259 int ecode2 = 0 ;
49260 int val3 ;
49261 int ecode3 = 0 ;
49262 PyObject * obj0 = 0 ;
49263 PyObject * obj1 = 0 ;
49264 PyObject * obj2 = 0 ;
49265 char * kwnames[] = {
49266 (char *) "self",(char *) "row",(char *) "col", NULL
49267 };
49268
49269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49271 if (!SWIG_IsOK(res1)) {
49272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49273 }
49274 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49275 if (obj1) {
49276 ecode2 = SWIG_AsVal_int(obj1, &val2);
49277 if (!SWIG_IsOK(ecode2)) {
49278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49279 }
49280 arg2 = static_cast< int >(val2);
49281 }
49282 if (obj2) {
49283 ecode3 = SWIG_AsVal_int(obj2, &val3);
49284 if (!SWIG_IsOK(ecode3)) {
49285 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49286 }
49287 arg3 = static_cast< int >(val3);
49288 }
49289 {
49290 PyThreadState* __tstate = wxPyBeginAllowThreads();
49291 wxGBPosition_Set(arg1,arg2,arg3);
49292 wxPyEndAllowThreads(__tstate);
49293 if (PyErr_Occurred()) SWIG_fail;
49294 }
49295 resultobj = SWIG_Py_Void();
49296 return resultobj;
49297 fail:
49298 return NULL;
49299 }
49300
49301
49302 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49303 PyObject *resultobj = 0;
49304 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49305 PyObject *result = 0 ;
49306 void *argp1 = 0 ;
49307 int res1 = 0 ;
49308 PyObject *swig_obj[1] ;
49309
49310 if (!args) SWIG_fail;
49311 swig_obj[0] = args;
49312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49313 if (!SWIG_IsOK(res1)) {
49314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49315 }
49316 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49317 {
49318 PyThreadState* __tstate = wxPyBeginAllowThreads();
49319 result = (PyObject *)wxGBPosition_Get(arg1);
49320 wxPyEndAllowThreads(__tstate);
49321 if (PyErr_Occurred()) SWIG_fail;
49322 }
49323 resultobj = result;
49324 return resultobj;
49325 fail:
49326 return NULL;
49327 }
49328
49329
49330 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49331 PyObject *obj;
49332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49333 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49334 return SWIG_Py_Void();
49335 }
49336
49337 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49338 return SWIG_Python_InitShadowInstance(args);
49339 }
49340
49341 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49342 PyObject *resultobj = 0;
49343 int arg1 = (int) 1 ;
49344 int arg2 = (int) 1 ;
49345 wxGBSpan *result = 0 ;
49346 int val1 ;
49347 int ecode1 = 0 ;
49348 int val2 ;
49349 int ecode2 = 0 ;
49350 PyObject * obj0 = 0 ;
49351 PyObject * obj1 = 0 ;
49352 char * kwnames[] = {
49353 (char *) "rowspan",(char *) "colspan", NULL
49354 };
49355
49356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49357 if (obj0) {
49358 ecode1 = SWIG_AsVal_int(obj0, &val1);
49359 if (!SWIG_IsOK(ecode1)) {
49360 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49361 }
49362 arg1 = static_cast< int >(val1);
49363 }
49364 if (obj1) {
49365 ecode2 = SWIG_AsVal_int(obj1, &val2);
49366 if (!SWIG_IsOK(ecode2)) {
49367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49368 }
49369 arg2 = static_cast< int >(val2);
49370 }
49371 {
49372 PyThreadState* __tstate = wxPyBeginAllowThreads();
49373 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49374 wxPyEndAllowThreads(__tstate);
49375 if (PyErr_Occurred()) SWIG_fail;
49376 }
49377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49378 return resultobj;
49379 fail:
49380 return NULL;
49381 }
49382
49383
49384 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49385 PyObject *resultobj = 0;
49386 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
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_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49394 if (!SWIG_IsOK(res1)) {
49395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49396 }
49397 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49398 {
49399 PyThreadState* __tstate = wxPyBeginAllowThreads();
49400 delete arg1;
49401
49402 wxPyEndAllowThreads(__tstate);
49403 if (PyErr_Occurred()) SWIG_fail;
49404 }
49405 resultobj = SWIG_Py_Void();
49406 return resultobj;
49407 fail:
49408 return NULL;
49409 }
49410
49411
49412 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49413 PyObject *resultobj = 0;
49414 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49415 int result;
49416 void *argp1 = 0 ;
49417 int res1 = 0 ;
49418 PyObject *swig_obj[1] ;
49419
49420 if (!args) SWIG_fail;
49421 swig_obj[0] = args;
49422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49423 if (!SWIG_IsOK(res1)) {
49424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49425 }
49426 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49427 {
49428 PyThreadState* __tstate = wxPyBeginAllowThreads();
49429 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49430 wxPyEndAllowThreads(__tstate);
49431 if (PyErr_Occurred()) SWIG_fail;
49432 }
49433 resultobj = SWIG_From_int(static_cast< int >(result));
49434 return resultobj;
49435 fail:
49436 return NULL;
49437 }
49438
49439
49440 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49441 PyObject *resultobj = 0;
49442 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49443 int result;
49444 void *argp1 = 0 ;
49445 int res1 = 0 ;
49446 PyObject *swig_obj[1] ;
49447
49448 if (!args) SWIG_fail;
49449 swig_obj[0] = args;
49450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49451 if (!SWIG_IsOK(res1)) {
49452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49453 }
49454 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49455 {
49456 PyThreadState* __tstate = wxPyBeginAllowThreads();
49457 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49458 wxPyEndAllowThreads(__tstate);
49459 if (PyErr_Occurred()) SWIG_fail;
49460 }
49461 resultobj = SWIG_From_int(static_cast< int >(result));
49462 return resultobj;
49463 fail:
49464 return NULL;
49465 }
49466
49467
49468 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49469 PyObject *resultobj = 0;
49470 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49471 int arg2 ;
49472 void *argp1 = 0 ;
49473 int res1 = 0 ;
49474 int val2 ;
49475 int ecode2 = 0 ;
49476 PyObject * obj0 = 0 ;
49477 PyObject * obj1 = 0 ;
49478 char * kwnames[] = {
49479 (char *) "self",(char *) "rowspan", NULL
49480 };
49481
49482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49484 if (!SWIG_IsOK(res1)) {
49485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49486 }
49487 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49488 ecode2 = SWIG_AsVal_int(obj1, &val2);
49489 if (!SWIG_IsOK(ecode2)) {
49490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49491 }
49492 arg2 = static_cast< int >(val2);
49493 {
49494 PyThreadState* __tstate = wxPyBeginAllowThreads();
49495 (arg1)->SetRowspan(arg2);
49496 wxPyEndAllowThreads(__tstate);
49497 if (PyErr_Occurred()) SWIG_fail;
49498 }
49499 resultobj = SWIG_Py_Void();
49500 return resultobj;
49501 fail:
49502 return NULL;
49503 }
49504
49505
49506 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49507 PyObject *resultobj = 0;
49508 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49509 int arg2 ;
49510 void *argp1 = 0 ;
49511 int res1 = 0 ;
49512 int val2 ;
49513 int ecode2 = 0 ;
49514 PyObject * obj0 = 0 ;
49515 PyObject * obj1 = 0 ;
49516 char * kwnames[] = {
49517 (char *) "self",(char *) "colspan", NULL
49518 };
49519
49520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49522 if (!SWIG_IsOK(res1)) {
49523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49524 }
49525 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49526 ecode2 = SWIG_AsVal_int(obj1, &val2);
49527 if (!SWIG_IsOK(ecode2)) {
49528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49529 }
49530 arg2 = static_cast< int >(val2);
49531 {
49532 PyThreadState* __tstate = wxPyBeginAllowThreads();
49533 (arg1)->SetColspan(arg2);
49534 wxPyEndAllowThreads(__tstate);
49535 if (PyErr_Occurred()) SWIG_fail;
49536 }
49537 resultobj = SWIG_Py_Void();
49538 return resultobj;
49539 fail:
49540 return NULL;
49541 }
49542
49543
49544 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49545 PyObject *resultobj = 0;
49546 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49547 PyObject *arg2 = (PyObject *) 0 ;
49548 bool result;
49549 void *argp1 = 0 ;
49550 int res1 = 0 ;
49551 PyObject * obj0 = 0 ;
49552 PyObject * obj1 = 0 ;
49553 char * kwnames[] = {
49554 (char *) "self",(char *) "other", NULL
49555 };
49556
49557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49559 if (!SWIG_IsOK(res1)) {
49560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49561 }
49562 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49563 arg2 = obj1;
49564 {
49565 result = (bool)wxGBSpan___eq__(arg1,arg2);
49566 if (PyErr_Occurred()) SWIG_fail;
49567 }
49568 {
49569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49570 }
49571 return resultobj;
49572 fail:
49573 return NULL;
49574 }
49575
49576
49577 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49578 PyObject *resultobj = 0;
49579 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49580 PyObject *arg2 = (PyObject *) 0 ;
49581 bool result;
49582 void *argp1 = 0 ;
49583 int res1 = 0 ;
49584 PyObject * obj0 = 0 ;
49585 PyObject * obj1 = 0 ;
49586 char * kwnames[] = {
49587 (char *) "self",(char *) "other", NULL
49588 };
49589
49590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49592 if (!SWIG_IsOK(res1)) {
49593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49594 }
49595 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49596 arg2 = obj1;
49597 {
49598 result = (bool)wxGBSpan___ne__(arg1,arg2);
49599 if (PyErr_Occurred()) SWIG_fail;
49600 }
49601 {
49602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49603 }
49604 return resultobj;
49605 fail:
49606 return NULL;
49607 }
49608
49609
49610 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49611 PyObject *resultobj = 0;
49612 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49613 int arg2 = (int) 1 ;
49614 int arg3 = (int) 1 ;
49615 void *argp1 = 0 ;
49616 int res1 = 0 ;
49617 int val2 ;
49618 int ecode2 = 0 ;
49619 int val3 ;
49620 int ecode3 = 0 ;
49621 PyObject * obj0 = 0 ;
49622 PyObject * obj1 = 0 ;
49623 PyObject * obj2 = 0 ;
49624 char * kwnames[] = {
49625 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49626 };
49627
49628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49630 if (!SWIG_IsOK(res1)) {
49631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49632 }
49633 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49634 if (obj1) {
49635 ecode2 = SWIG_AsVal_int(obj1, &val2);
49636 if (!SWIG_IsOK(ecode2)) {
49637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49638 }
49639 arg2 = static_cast< int >(val2);
49640 }
49641 if (obj2) {
49642 ecode3 = SWIG_AsVal_int(obj2, &val3);
49643 if (!SWIG_IsOK(ecode3)) {
49644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49645 }
49646 arg3 = static_cast< int >(val3);
49647 }
49648 {
49649 PyThreadState* __tstate = wxPyBeginAllowThreads();
49650 wxGBSpan_Set(arg1,arg2,arg3);
49651 wxPyEndAllowThreads(__tstate);
49652 if (PyErr_Occurred()) SWIG_fail;
49653 }
49654 resultobj = SWIG_Py_Void();
49655 return resultobj;
49656 fail:
49657 return NULL;
49658 }
49659
49660
49661 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49662 PyObject *resultobj = 0;
49663 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49664 PyObject *result = 0 ;
49665 void *argp1 = 0 ;
49666 int res1 = 0 ;
49667 PyObject *swig_obj[1] ;
49668
49669 if (!args) SWIG_fail;
49670 swig_obj[0] = args;
49671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49672 if (!SWIG_IsOK(res1)) {
49673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49674 }
49675 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49676 {
49677 PyThreadState* __tstate = wxPyBeginAllowThreads();
49678 result = (PyObject *)wxGBSpan_Get(arg1);
49679 wxPyEndAllowThreads(__tstate);
49680 if (PyErr_Occurred()) SWIG_fail;
49681 }
49682 resultobj = result;
49683 return resultobj;
49684 fail:
49685 return NULL;
49686 }
49687
49688
49689 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49690 PyObject *obj;
49691 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49692 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49693 return SWIG_Py_Void();
49694 }
49695
49696 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49697 return SWIG_Python_InitShadowInstance(args);
49698 }
49699
49700 SWIGINTERN int DefaultSpan_set(PyObject *) {
49701 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49702 return 1;
49703 }
49704
49705
49706 SWIGINTERN PyObject *DefaultSpan_get(void) {
49707 PyObject *pyobj = 0;
49708
49709 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49710 return pyobj;
49711 }
49712
49713
49714 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49715 PyObject *resultobj = 0;
49716 wxGBSizerItem *result = 0 ;
49717
49718 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49719 {
49720 PyThreadState* __tstate = wxPyBeginAllowThreads();
49721 result = (wxGBSizerItem *)new wxGBSizerItem();
49722 wxPyEndAllowThreads(__tstate);
49723 if (PyErr_Occurred()) SWIG_fail;
49724 }
49725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49726 return resultobj;
49727 fail:
49728 return NULL;
49729 }
49730
49731
49732 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49733 PyObject *resultobj = 0;
49734 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49735 void *argp1 = 0 ;
49736 int res1 = 0 ;
49737 PyObject *swig_obj[1] ;
49738
49739 if (!args) SWIG_fail;
49740 swig_obj[0] = args;
49741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49742 if (!SWIG_IsOK(res1)) {
49743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49744 }
49745 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49746 {
49747 PyThreadState* __tstate = wxPyBeginAllowThreads();
49748 delete arg1;
49749
49750 wxPyEndAllowThreads(__tstate);
49751 if (PyErr_Occurred()) SWIG_fail;
49752 }
49753 resultobj = SWIG_Py_Void();
49754 return resultobj;
49755 fail:
49756 return NULL;
49757 }
49758
49759
49760 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49761 PyObject *resultobj = 0;
49762 wxWindow *arg1 = (wxWindow *) 0 ;
49763 wxGBPosition *arg2 = 0 ;
49764 wxGBSpan *arg3 = 0 ;
49765 int arg4 ;
49766 int arg5 ;
49767 PyObject *arg6 = (PyObject *) NULL ;
49768 wxGBSizerItem *result = 0 ;
49769 void *argp1 = 0 ;
49770 int res1 = 0 ;
49771 wxGBPosition temp2 ;
49772 wxGBSpan temp3 ;
49773 int val4 ;
49774 int ecode4 = 0 ;
49775 int val5 ;
49776 int ecode5 = 0 ;
49777 PyObject * obj0 = 0 ;
49778 PyObject * obj1 = 0 ;
49779 PyObject * obj2 = 0 ;
49780 PyObject * obj3 = 0 ;
49781 PyObject * obj4 = 0 ;
49782 PyObject * obj5 = 0 ;
49783 char * kwnames[] = {
49784 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49785 };
49786
49787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49789 if (!SWIG_IsOK(res1)) {
49790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49791 }
49792 arg1 = reinterpret_cast< wxWindow * >(argp1);
49793 {
49794 arg2 = &temp2;
49795 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49796 }
49797 {
49798 arg3 = &temp3;
49799 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49800 }
49801 ecode4 = SWIG_AsVal_int(obj3, &val4);
49802 if (!SWIG_IsOK(ecode4)) {
49803 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49804 }
49805 arg4 = static_cast< int >(val4);
49806 ecode5 = SWIG_AsVal_int(obj4, &val5);
49807 if (!SWIG_IsOK(ecode5)) {
49808 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49809 }
49810 arg5 = static_cast< int >(val5);
49811 if (obj5) {
49812 arg6 = obj5;
49813 }
49814 {
49815 PyThreadState* __tstate = wxPyBeginAllowThreads();
49816 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49817 wxPyEndAllowThreads(__tstate);
49818 if (PyErr_Occurred()) SWIG_fail;
49819 }
49820 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49821 return resultobj;
49822 fail:
49823 return NULL;
49824 }
49825
49826
49827 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49828 PyObject *resultobj = 0;
49829 wxSizer *arg1 = (wxSizer *) 0 ;
49830 wxGBPosition *arg2 = 0 ;
49831 wxGBSpan *arg3 = 0 ;
49832 int arg4 ;
49833 int arg5 ;
49834 PyObject *arg6 = (PyObject *) NULL ;
49835 wxGBSizerItem *result = 0 ;
49836 int res1 = 0 ;
49837 wxGBPosition temp2 ;
49838 wxGBSpan temp3 ;
49839 int val4 ;
49840 int ecode4 = 0 ;
49841 int val5 ;
49842 int ecode5 = 0 ;
49843 PyObject * obj0 = 0 ;
49844 PyObject * obj1 = 0 ;
49845 PyObject * obj2 = 0 ;
49846 PyObject * obj3 = 0 ;
49847 PyObject * obj4 = 0 ;
49848 PyObject * obj5 = 0 ;
49849 char * kwnames[] = {
49850 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49851 };
49852
49853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49854 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49855 if (!SWIG_IsOK(res1)) {
49856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49857 }
49858 {
49859 arg2 = &temp2;
49860 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49861 }
49862 {
49863 arg3 = &temp3;
49864 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49865 }
49866 ecode4 = SWIG_AsVal_int(obj3, &val4);
49867 if (!SWIG_IsOK(ecode4)) {
49868 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49869 }
49870 arg4 = static_cast< int >(val4);
49871 ecode5 = SWIG_AsVal_int(obj4, &val5);
49872 if (!SWIG_IsOK(ecode5)) {
49873 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49874 }
49875 arg5 = static_cast< int >(val5);
49876 if (obj5) {
49877 arg6 = obj5;
49878 }
49879 {
49880 PyThreadState* __tstate = wxPyBeginAllowThreads();
49881 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49882 wxPyEndAllowThreads(__tstate);
49883 if (PyErr_Occurred()) SWIG_fail;
49884 }
49885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49886 return resultobj;
49887 fail:
49888 return NULL;
49889 }
49890
49891
49892 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49893 PyObject *resultobj = 0;
49894 int arg1 ;
49895 int arg2 ;
49896 wxGBPosition *arg3 = 0 ;
49897 wxGBSpan *arg4 = 0 ;
49898 int arg5 ;
49899 int arg6 ;
49900 PyObject *arg7 = (PyObject *) NULL ;
49901 wxGBSizerItem *result = 0 ;
49902 int val1 ;
49903 int ecode1 = 0 ;
49904 int val2 ;
49905 int ecode2 = 0 ;
49906 wxGBPosition temp3 ;
49907 wxGBSpan temp4 ;
49908 int val5 ;
49909 int ecode5 = 0 ;
49910 int val6 ;
49911 int ecode6 = 0 ;
49912 PyObject * obj0 = 0 ;
49913 PyObject * obj1 = 0 ;
49914 PyObject * obj2 = 0 ;
49915 PyObject * obj3 = 0 ;
49916 PyObject * obj4 = 0 ;
49917 PyObject * obj5 = 0 ;
49918 PyObject * obj6 = 0 ;
49919 char * kwnames[] = {
49920 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49921 };
49922
49923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49924 ecode1 = SWIG_AsVal_int(obj0, &val1);
49925 if (!SWIG_IsOK(ecode1)) {
49926 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49927 }
49928 arg1 = static_cast< int >(val1);
49929 ecode2 = SWIG_AsVal_int(obj1, &val2);
49930 if (!SWIG_IsOK(ecode2)) {
49931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49932 }
49933 arg2 = static_cast< int >(val2);
49934 {
49935 arg3 = &temp3;
49936 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49937 }
49938 {
49939 arg4 = &temp4;
49940 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49941 }
49942 ecode5 = SWIG_AsVal_int(obj4, &val5);
49943 if (!SWIG_IsOK(ecode5)) {
49944 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49945 }
49946 arg5 = static_cast< int >(val5);
49947 ecode6 = SWIG_AsVal_int(obj5, &val6);
49948 if (!SWIG_IsOK(ecode6)) {
49949 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49950 }
49951 arg6 = static_cast< int >(val6);
49952 if (obj6) {
49953 arg7 = obj6;
49954 }
49955 {
49956 PyThreadState* __tstate = wxPyBeginAllowThreads();
49957 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49958 wxPyEndAllowThreads(__tstate);
49959 if (PyErr_Occurred()) SWIG_fail;
49960 }
49961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49962 return resultobj;
49963 fail:
49964 return NULL;
49965 }
49966
49967
49968 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49969 PyObject *resultobj = 0;
49970 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49971 wxGBPosition result;
49972 void *argp1 = 0 ;
49973 int res1 = 0 ;
49974 PyObject *swig_obj[1] ;
49975
49976 if (!args) SWIG_fail;
49977 swig_obj[0] = args;
49978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49979 if (!SWIG_IsOK(res1)) {
49980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49981 }
49982 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49983 {
49984 PyThreadState* __tstate = wxPyBeginAllowThreads();
49985 result = ((wxGBSizerItem const *)arg1)->GetPos();
49986 wxPyEndAllowThreads(__tstate);
49987 if (PyErr_Occurred()) SWIG_fail;
49988 }
49989 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49990 return resultobj;
49991 fail:
49992 return NULL;
49993 }
49994
49995
49996 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49997 PyObject *resultobj = 0;
49998 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49999 wxGBSpan result;
50000 void *argp1 = 0 ;
50001 int res1 = 0 ;
50002 PyObject *swig_obj[1] ;
50003
50004 if (!args) SWIG_fail;
50005 swig_obj[0] = args;
50006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50007 if (!SWIG_IsOK(res1)) {
50008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50009 }
50010 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50011 {
50012 PyThreadState* __tstate = wxPyBeginAllowThreads();
50013 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50014 wxPyEndAllowThreads(__tstate);
50015 if (PyErr_Occurred()) SWIG_fail;
50016 }
50017 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50018 return resultobj;
50019 fail:
50020 return NULL;
50021 }
50022
50023
50024 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50025 PyObject *resultobj = 0;
50026 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50027 wxGBPosition *arg2 = 0 ;
50028 bool result;
50029 void *argp1 = 0 ;
50030 int res1 = 0 ;
50031 wxGBPosition temp2 ;
50032 PyObject * obj0 = 0 ;
50033 PyObject * obj1 = 0 ;
50034 char * kwnames[] = {
50035 (char *) "self",(char *) "pos", NULL
50036 };
50037
50038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50040 if (!SWIG_IsOK(res1)) {
50041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50042 }
50043 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50044 {
50045 arg2 = &temp2;
50046 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50047 }
50048 {
50049 PyThreadState* __tstate = wxPyBeginAllowThreads();
50050 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50051 wxPyEndAllowThreads(__tstate);
50052 if (PyErr_Occurred()) SWIG_fail;
50053 }
50054 {
50055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50056 }
50057 return resultobj;
50058 fail:
50059 return NULL;
50060 }
50061
50062
50063 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50064 PyObject *resultobj = 0;
50065 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50066 wxGBSpan *arg2 = 0 ;
50067 bool result;
50068 void *argp1 = 0 ;
50069 int res1 = 0 ;
50070 wxGBSpan temp2 ;
50071 PyObject * obj0 = 0 ;
50072 PyObject * obj1 = 0 ;
50073 char * kwnames[] = {
50074 (char *) "self",(char *) "span", NULL
50075 };
50076
50077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50079 if (!SWIG_IsOK(res1)) {
50080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50081 }
50082 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50083 {
50084 arg2 = &temp2;
50085 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50086 }
50087 {
50088 PyThreadState* __tstate = wxPyBeginAllowThreads();
50089 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50090 wxPyEndAllowThreads(__tstate);
50091 if (PyErr_Occurred()) SWIG_fail;
50092 }
50093 {
50094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50095 }
50096 return resultobj;
50097 fail:
50098 return NULL;
50099 }
50100
50101
50102 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50103 PyObject *resultobj = 0;
50104 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50105 wxGBSizerItem *arg2 = 0 ;
50106 bool result;
50107 void *argp1 = 0 ;
50108 int res1 = 0 ;
50109 void *argp2 = 0 ;
50110 int res2 = 0 ;
50111 PyObject * obj0 = 0 ;
50112 PyObject * obj1 = 0 ;
50113 char * kwnames[] = {
50114 (char *) "self",(char *) "other", NULL
50115 };
50116
50117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50119 if (!SWIG_IsOK(res1)) {
50120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50121 }
50122 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50123 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50124 if (!SWIG_IsOK(res2)) {
50125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50126 }
50127 if (!argp2) {
50128 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50129 }
50130 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50131 {
50132 PyThreadState* __tstate = wxPyBeginAllowThreads();
50133 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50134 wxPyEndAllowThreads(__tstate);
50135 if (PyErr_Occurred()) SWIG_fail;
50136 }
50137 {
50138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50139 }
50140 return resultobj;
50141 fail:
50142 return NULL;
50143 }
50144
50145
50146 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50147 PyObject *resultobj = 0;
50148 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50149 wxGBPosition *arg2 = 0 ;
50150 wxGBSpan *arg3 = 0 ;
50151 bool result;
50152 void *argp1 = 0 ;
50153 int res1 = 0 ;
50154 wxGBPosition temp2 ;
50155 wxGBSpan temp3 ;
50156 PyObject * obj0 = 0 ;
50157 PyObject * obj1 = 0 ;
50158 PyObject * obj2 = 0 ;
50159 char * kwnames[] = {
50160 (char *) "self",(char *) "pos",(char *) "span", NULL
50161 };
50162
50163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50165 if (!SWIG_IsOK(res1)) {
50166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50167 }
50168 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50169 {
50170 arg2 = &temp2;
50171 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50172 }
50173 {
50174 arg3 = &temp3;
50175 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50176 }
50177 {
50178 PyThreadState* __tstate = wxPyBeginAllowThreads();
50179 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50180 wxPyEndAllowThreads(__tstate);
50181 if (PyErr_Occurred()) SWIG_fail;
50182 }
50183 {
50184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50185 }
50186 return resultobj;
50187 fail:
50188 return NULL;
50189 }
50190
50191
50192 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50193 PyObject *resultobj = 0;
50194 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50195 wxGBPosition result;
50196 void *argp1 = 0 ;
50197 int res1 = 0 ;
50198 PyObject *swig_obj[1] ;
50199
50200 if (!args) SWIG_fail;
50201 swig_obj[0] = args;
50202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50203 if (!SWIG_IsOK(res1)) {
50204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50205 }
50206 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50207 {
50208 PyThreadState* __tstate = wxPyBeginAllowThreads();
50209 result = wxGBSizerItem_GetEndPos(arg1);
50210 wxPyEndAllowThreads(__tstate);
50211 if (PyErr_Occurred()) SWIG_fail;
50212 }
50213 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50214 return resultobj;
50215 fail:
50216 return NULL;
50217 }
50218
50219
50220 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50221 PyObject *resultobj = 0;
50222 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50223 wxGridBagSizer *result = 0 ;
50224 void *argp1 = 0 ;
50225 int res1 = 0 ;
50226 PyObject *swig_obj[1] ;
50227
50228 if (!args) SWIG_fail;
50229 swig_obj[0] = args;
50230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50231 if (!SWIG_IsOK(res1)) {
50232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50233 }
50234 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50235 {
50236 PyThreadState* __tstate = wxPyBeginAllowThreads();
50237 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50238 wxPyEndAllowThreads(__tstate);
50239 if (PyErr_Occurred()) SWIG_fail;
50240 }
50241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50242 return resultobj;
50243 fail:
50244 return NULL;
50245 }
50246
50247
50248 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50249 PyObject *resultobj = 0;
50250 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50251 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50252 void *argp1 = 0 ;
50253 int res1 = 0 ;
50254 void *argp2 = 0 ;
50255 int res2 = 0 ;
50256 PyObject * obj0 = 0 ;
50257 PyObject * obj1 = 0 ;
50258 char * kwnames[] = {
50259 (char *) "self",(char *) "sizer", NULL
50260 };
50261
50262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50264 if (!SWIG_IsOK(res1)) {
50265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50266 }
50267 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50268 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50269 if (!SWIG_IsOK(res2)) {
50270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50271 }
50272 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50273 {
50274 PyThreadState* __tstate = wxPyBeginAllowThreads();
50275 (arg1)->SetGBSizer(arg2);
50276 wxPyEndAllowThreads(__tstate);
50277 if (PyErr_Occurred()) SWIG_fail;
50278 }
50279 resultobj = SWIG_Py_Void();
50280 return resultobj;
50281 fail:
50282 return NULL;
50283 }
50284
50285
50286 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50287 PyObject *obj;
50288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50289 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50290 return SWIG_Py_Void();
50291 }
50292
50293 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50294 return SWIG_Python_InitShadowInstance(args);
50295 }
50296
50297 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50298 PyObject *resultobj = 0;
50299 int arg1 = (int) 0 ;
50300 int arg2 = (int) 0 ;
50301 wxGridBagSizer *result = 0 ;
50302 int val1 ;
50303 int ecode1 = 0 ;
50304 int val2 ;
50305 int ecode2 = 0 ;
50306 PyObject * obj0 = 0 ;
50307 PyObject * obj1 = 0 ;
50308 char * kwnames[] = {
50309 (char *) "vgap",(char *) "hgap", NULL
50310 };
50311
50312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50313 if (obj0) {
50314 ecode1 = SWIG_AsVal_int(obj0, &val1);
50315 if (!SWIG_IsOK(ecode1)) {
50316 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50317 }
50318 arg1 = static_cast< int >(val1);
50319 }
50320 if (obj1) {
50321 ecode2 = SWIG_AsVal_int(obj1, &val2);
50322 if (!SWIG_IsOK(ecode2)) {
50323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50324 }
50325 arg2 = static_cast< int >(val2);
50326 }
50327 {
50328 PyThreadState* __tstate = wxPyBeginAllowThreads();
50329 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50330 wxPyEndAllowThreads(__tstate);
50331 if (PyErr_Occurred()) SWIG_fail;
50332 }
50333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50334 return resultobj;
50335 fail:
50336 return NULL;
50337 }
50338
50339
50340 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50341 PyObject *resultobj = 0;
50342 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50343 PyObject *arg2 = (PyObject *) 0 ;
50344 wxGBPosition *arg3 = 0 ;
50345 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50346 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50347 int arg5 = (int) 0 ;
50348 int arg6 = (int) 0 ;
50349 PyObject *arg7 = (PyObject *) NULL ;
50350 wxGBSizerItem *result = 0 ;
50351 void *argp1 = 0 ;
50352 int res1 = 0 ;
50353 wxGBPosition temp3 ;
50354 wxGBSpan temp4 ;
50355 int val5 ;
50356 int ecode5 = 0 ;
50357 int val6 ;
50358 int ecode6 = 0 ;
50359 PyObject * obj0 = 0 ;
50360 PyObject * obj1 = 0 ;
50361 PyObject * obj2 = 0 ;
50362 PyObject * obj3 = 0 ;
50363 PyObject * obj4 = 0 ;
50364 PyObject * obj5 = 0 ;
50365 PyObject * obj6 = 0 ;
50366 char * kwnames[] = {
50367 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50368 };
50369
50370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50372 if (!SWIG_IsOK(res1)) {
50373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50374 }
50375 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50376 arg2 = obj1;
50377 {
50378 arg3 = &temp3;
50379 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50380 }
50381 if (obj3) {
50382 {
50383 arg4 = &temp4;
50384 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50385 }
50386 }
50387 if (obj4) {
50388 ecode5 = SWIG_AsVal_int(obj4, &val5);
50389 if (!SWIG_IsOK(ecode5)) {
50390 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50391 }
50392 arg5 = static_cast< int >(val5);
50393 }
50394 if (obj5) {
50395 ecode6 = SWIG_AsVal_int(obj5, &val6);
50396 if (!SWIG_IsOK(ecode6)) {
50397 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50398 }
50399 arg6 = static_cast< int >(val6);
50400 }
50401 if (obj6) {
50402 arg7 = obj6;
50403 }
50404 {
50405 PyThreadState* __tstate = wxPyBeginAllowThreads();
50406 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50407 wxPyEndAllowThreads(__tstate);
50408 if (PyErr_Occurred()) SWIG_fail;
50409 }
50410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50411 return resultobj;
50412 fail:
50413 return NULL;
50414 }
50415
50416
50417 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50418 PyObject *resultobj = 0;
50419 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50420 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50421 wxGBSizerItem *result = 0 ;
50422 void *argp1 = 0 ;
50423 int res1 = 0 ;
50424 int res2 = 0 ;
50425 PyObject * obj0 = 0 ;
50426 PyObject * obj1 = 0 ;
50427 char * kwnames[] = {
50428 (char *) "self",(char *) "item", NULL
50429 };
50430
50431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50433 if (!SWIG_IsOK(res1)) {
50434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50435 }
50436 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50437 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50438 if (!SWIG_IsOK(res2)) {
50439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50440 }
50441 {
50442 PyThreadState* __tstate = wxPyBeginAllowThreads();
50443 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50444 wxPyEndAllowThreads(__tstate);
50445 if (PyErr_Occurred()) SWIG_fail;
50446 }
50447 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50448 return resultobj;
50449 fail:
50450 return NULL;
50451 }
50452
50453
50454 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50455 PyObject *resultobj = 0;
50456 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50457 int arg2 ;
50458 int arg3 ;
50459 wxSize result;
50460 void *argp1 = 0 ;
50461 int res1 = 0 ;
50462 int val2 ;
50463 int ecode2 = 0 ;
50464 int val3 ;
50465 int ecode3 = 0 ;
50466 PyObject * obj0 = 0 ;
50467 PyObject * obj1 = 0 ;
50468 PyObject * obj2 = 0 ;
50469 char * kwnames[] = {
50470 (char *) "self",(char *) "row",(char *) "col", NULL
50471 };
50472
50473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50475 if (!SWIG_IsOK(res1)) {
50476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50477 }
50478 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50479 ecode2 = SWIG_AsVal_int(obj1, &val2);
50480 if (!SWIG_IsOK(ecode2)) {
50481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50482 }
50483 arg2 = static_cast< int >(val2);
50484 ecode3 = SWIG_AsVal_int(obj2, &val3);
50485 if (!SWIG_IsOK(ecode3)) {
50486 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50487 }
50488 arg3 = static_cast< int >(val3);
50489 {
50490 PyThreadState* __tstate = wxPyBeginAllowThreads();
50491 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50492 wxPyEndAllowThreads(__tstate);
50493 if (PyErr_Occurred()) SWIG_fail;
50494 }
50495 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50496 return resultobj;
50497 fail:
50498 return NULL;
50499 }
50500
50501
50502 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50503 PyObject *resultobj = 0;
50504 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50505 wxSize result;
50506 void *argp1 = 0 ;
50507 int res1 = 0 ;
50508 PyObject *swig_obj[1] ;
50509
50510 if (!args) SWIG_fail;
50511 swig_obj[0] = args;
50512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50513 if (!SWIG_IsOK(res1)) {
50514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50515 }
50516 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50517 {
50518 PyThreadState* __tstate = wxPyBeginAllowThreads();
50519 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50520 wxPyEndAllowThreads(__tstate);
50521 if (PyErr_Occurred()) SWIG_fail;
50522 }
50523 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50524 return resultobj;
50525 fail:
50526 return NULL;
50527 }
50528
50529
50530 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50531 PyObject *resultobj = 0;
50532 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50533 wxSize *arg2 = 0 ;
50534 void *argp1 = 0 ;
50535 int res1 = 0 ;
50536 wxSize temp2 ;
50537 PyObject * obj0 = 0 ;
50538 PyObject * obj1 = 0 ;
50539 char * kwnames[] = {
50540 (char *) "self",(char *) "sz", NULL
50541 };
50542
50543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50545 if (!SWIG_IsOK(res1)) {
50546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50547 }
50548 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50549 {
50550 arg2 = &temp2;
50551 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50552 }
50553 {
50554 PyThreadState* __tstate = wxPyBeginAllowThreads();
50555 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50556 wxPyEndAllowThreads(__tstate);
50557 if (PyErr_Occurred()) SWIG_fail;
50558 }
50559 resultobj = SWIG_Py_Void();
50560 return resultobj;
50561 fail:
50562 return NULL;
50563 }
50564
50565
50566 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50567 PyObject *resultobj = 0;
50568 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50569 wxWindow *arg2 = (wxWindow *) 0 ;
50570 wxGBPosition result;
50571 void *argp1 = 0 ;
50572 int res1 = 0 ;
50573 void *argp2 = 0 ;
50574 int res2 = 0 ;
50575
50576 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50578 if (!SWIG_IsOK(res1)) {
50579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50580 }
50581 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50582 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50583 if (!SWIG_IsOK(res2)) {
50584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50585 }
50586 arg2 = reinterpret_cast< wxWindow * >(argp2);
50587 {
50588 PyThreadState* __tstate = wxPyBeginAllowThreads();
50589 result = (arg1)->GetItemPosition(arg2);
50590 wxPyEndAllowThreads(__tstate);
50591 if (PyErr_Occurred()) SWIG_fail;
50592 }
50593 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50594 return resultobj;
50595 fail:
50596 return NULL;
50597 }
50598
50599
50600 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50601 PyObject *resultobj = 0;
50602 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50603 wxSizer *arg2 = (wxSizer *) 0 ;
50604 wxGBPosition result;
50605 void *argp1 = 0 ;
50606 int res1 = 0 ;
50607 void *argp2 = 0 ;
50608 int res2 = 0 ;
50609
50610 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50612 if (!SWIG_IsOK(res1)) {
50613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50614 }
50615 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50616 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50617 if (!SWIG_IsOK(res2)) {
50618 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50619 }
50620 arg2 = reinterpret_cast< wxSizer * >(argp2);
50621 {
50622 PyThreadState* __tstate = wxPyBeginAllowThreads();
50623 result = (arg1)->GetItemPosition(arg2);
50624 wxPyEndAllowThreads(__tstate);
50625 if (PyErr_Occurred()) SWIG_fail;
50626 }
50627 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50628 return resultobj;
50629 fail:
50630 return NULL;
50631 }
50632
50633
50634 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50635 PyObject *resultobj = 0;
50636 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50637 size_t arg2 ;
50638 wxGBPosition result;
50639 void *argp1 = 0 ;
50640 int res1 = 0 ;
50641 size_t val2 ;
50642 int ecode2 = 0 ;
50643
50644 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50646 if (!SWIG_IsOK(res1)) {
50647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50648 }
50649 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50650 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50651 if (!SWIG_IsOK(ecode2)) {
50652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50653 }
50654 arg2 = static_cast< size_t >(val2);
50655 {
50656 PyThreadState* __tstate = wxPyBeginAllowThreads();
50657 result = (arg1)->GetItemPosition(arg2);
50658 wxPyEndAllowThreads(__tstate);
50659 if (PyErr_Occurred()) SWIG_fail;
50660 }
50661 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50662 return resultobj;
50663 fail:
50664 return NULL;
50665 }
50666
50667
50668 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50669 int argc;
50670 PyObject *argv[3];
50671
50672 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50673 --argc;
50674 if (argc == 2) {
50675 int _v = 0;
50676 {
50677 void *vptr = 0;
50678 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50679 _v = SWIG_CheckState(res);
50680 }
50681 if (!_v) goto check_1;
50682 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50683 }
50684 check_1:
50685
50686 if (argc == 2) {
50687 int _v = 0;
50688 {
50689 void *vptr = 0;
50690 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50691 _v = SWIG_CheckState(res);
50692 }
50693 if (!_v) goto check_2;
50694 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50695 }
50696 check_2:
50697
50698 if (argc == 2) {
50699 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50700 }
50701
50702 fail:
50703 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50704 return NULL;
50705 }
50706
50707
50708 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50709 PyObject *resultobj = 0;
50710 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50711 wxWindow *arg2 = (wxWindow *) 0 ;
50712 wxGBPosition *arg3 = 0 ;
50713 bool result;
50714 void *argp1 = 0 ;
50715 int res1 = 0 ;
50716 void *argp2 = 0 ;
50717 int res2 = 0 ;
50718 wxGBPosition temp3 ;
50719
50720 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50722 if (!SWIG_IsOK(res1)) {
50723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50724 }
50725 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50726 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50727 if (!SWIG_IsOK(res2)) {
50728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50729 }
50730 arg2 = reinterpret_cast< wxWindow * >(argp2);
50731 {
50732 arg3 = &temp3;
50733 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50734 }
50735 {
50736 PyThreadState* __tstate = wxPyBeginAllowThreads();
50737 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50738 wxPyEndAllowThreads(__tstate);
50739 if (PyErr_Occurred()) SWIG_fail;
50740 }
50741 {
50742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50743 }
50744 return resultobj;
50745 fail:
50746 return NULL;
50747 }
50748
50749
50750 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50751 PyObject *resultobj = 0;
50752 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50753 wxSizer *arg2 = (wxSizer *) 0 ;
50754 wxGBPosition *arg3 = 0 ;
50755 bool result;
50756 void *argp1 = 0 ;
50757 int res1 = 0 ;
50758 void *argp2 = 0 ;
50759 int res2 = 0 ;
50760 wxGBPosition temp3 ;
50761
50762 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50764 if (!SWIG_IsOK(res1)) {
50765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50766 }
50767 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50768 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50769 if (!SWIG_IsOK(res2)) {
50770 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50771 }
50772 arg2 = reinterpret_cast< wxSizer * >(argp2);
50773 {
50774 arg3 = &temp3;
50775 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50776 }
50777 {
50778 PyThreadState* __tstate = wxPyBeginAllowThreads();
50779 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50780 wxPyEndAllowThreads(__tstate);
50781 if (PyErr_Occurred()) SWIG_fail;
50782 }
50783 {
50784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50785 }
50786 return resultobj;
50787 fail:
50788 return NULL;
50789 }
50790
50791
50792 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50793 PyObject *resultobj = 0;
50794 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50795 size_t arg2 ;
50796 wxGBPosition *arg3 = 0 ;
50797 bool result;
50798 void *argp1 = 0 ;
50799 int res1 = 0 ;
50800 size_t val2 ;
50801 int ecode2 = 0 ;
50802 wxGBPosition temp3 ;
50803
50804 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50806 if (!SWIG_IsOK(res1)) {
50807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50808 }
50809 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50810 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50811 if (!SWIG_IsOK(ecode2)) {
50812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50813 }
50814 arg2 = static_cast< size_t >(val2);
50815 {
50816 arg3 = &temp3;
50817 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50818 }
50819 {
50820 PyThreadState* __tstate = wxPyBeginAllowThreads();
50821 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50822 wxPyEndAllowThreads(__tstate);
50823 if (PyErr_Occurred()) SWIG_fail;
50824 }
50825 {
50826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50827 }
50828 return resultobj;
50829 fail:
50830 return NULL;
50831 }
50832
50833
50834 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50835 int argc;
50836 PyObject *argv[4];
50837
50838 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50839 --argc;
50840 if (argc == 3) {
50841 int _v = 0;
50842 {
50843 void *vptr = 0;
50844 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50845 _v = SWIG_CheckState(res);
50846 }
50847 if (!_v) goto check_1;
50848 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50849 }
50850 check_1:
50851
50852 if (argc == 3) {
50853 int _v = 0;
50854 {
50855 void *vptr = 0;
50856 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50857 _v = SWIG_CheckState(res);
50858 }
50859 if (!_v) goto check_2;
50860 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50861 }
50862 check_2:
50863
50864 if (argc == 3) {
50865 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50866 }
50867
50868 fail:
50869 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50870 return NULL;
50871 }
50872
50873
50874 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50875 PyObject *resultobj = 0;
50876 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50877 wxWindow *arg2 = (wxWindow *) 0 ;
50878 wxGBSpan result;
50879 void *argp1 = 0 ;
50880 int res1 = 0 ;
50881 void *argp2 = 0 ;
50882 int res2 = 0 ;
50883
50884 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50886 if (!SWIG_IsOK(res1)) {
50887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50888 }
50889 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50890 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50891 if (!SWIG_IsOK(res2)) {
50892 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50893 }
50894 arg2 = reinterpret_cast< wxWindow * >(argp2);
50895 {
50896 PyThreadState* __tstate = wxPyBeginAllowThreads();
50897 result = (arg1)->GetItemSpan(arg2);
50898 wxPyEndAllowThreads(__tstate);
50899 if (PyErr_Occurred()) SWIG_fail;
50900 }
50901 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50902 return resultobj;
50903 fail:
50904 return NULL;
50905 }
50906
50907
50908 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50909 PyObject *resultobj = 0;
50910 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50911 wxSizer *arg2 = (wxSizer *) 0 ;
50912 wxGBSpan result;
50913 void *argp1 = 0 ;
50914 int res1 = 0 ;
50915 void *argp2 = 0 ;
50916 int res2 = 0 ;
50917
50918 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50920 if (!SWIG_IsOK(res1)) {
50921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50922 }
50923 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50924 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50925 if (!SWIG_IsOK(res2)) {
50926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50927 }
50928 arg2 = reinterpret_cast< wxSizer * >(argp2);
50929 {
50930 PyThreadState* __tstate = wxPyBeginAllowThreads();
50931 result = (arg1)->GetItemSpan(arg2);
50932 wxPyEndAllowThreads(__tstate);
50933 if (PyErr_Occurred()) SWIG_fail;
50934 }
50935 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50936 return resultobj;
50937 fail:
50938 return NULL;
50939 }
50940
50941
50942 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50943 PyObject *resultobj = 0;
50944 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50945 size_t arg2 ;
50946 wxGBSpan result;
50947 void *argp1 = 0 ;
50948 int res1 = 0 ;
50949 size_t val2 ;
50950 int ecode2 = 0 ;
50951
50952 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50954 if (!SWIG_IsOK(res1)) {
50955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50956 }
50957 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50958 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50959 if (!SWIG_IsOK(ecode2)) {
50960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50961 }
50962 arg2 = static_cast< size_t >(val2);
50963 {
50964 PyThreadState* __tstate = wxPyBeginAllowThreads();
50965 result = (arg1)->GetItemSpan(arg2);
50966 wxPyEndAllowThreads(__tstate);
50967 if (PyErr_Occurred()) SWIG_fail;
50968 }
50969 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50970 return resultobj;
50971 fail:
50972 return NULL;
50973 }
50974
50975
50976 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50977 int argc;
50978 PyObject *argv[3];
50979
50980 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50981 --argc;
50982 if (argc == 2) {
50983 int _v = 0;
50984 {
50985 void *vptr = 0;
50986 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50987 _v = SWIG_CheckState(res);
50988 }
50989 if (!_v) goto check_1;
50990 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50991 }
50992 check_1:
50993
50994 if (argc == 2) {
50995 int _v = 0;
50996 {
50997 void *vptr = 0;
50998 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50999 _v = SWIG_CheckState(res);
51000 }
51001 if (!_v) goto check_2;
51002 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51003 }
51004 check_2:
51005
51006 if (argc == 2) {
51007 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51008 }
51009
51010 fail:
51011 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51012 return NULL;
51013 }
51014
51015
51016 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51017 PyObject *resultobj = 0;
51018 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51019 wxWindow *arg2 = (wxWindow *) 0 ;
51020 wxGBSpan *arg3 = 0 ;
51021 bool result;
51022 void *argp1 = 0 ;
51023 int res1 = 0 ;
51024 void *argp2 = 0 ;
51025 int res2 = 0 ;
51026 wxGBSpan temp3 ;
51027
51028 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51030 if (!SWIG_IsOK(res1)) {
51031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51032 }
51033 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51034 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51035 if (!SWIG_IsOK(res2)) {
51036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51037 }
51038 arg2 = reinterpret_cast< wxWindow * >(argp2);
51039 {
51040 arg3 = &temp3;
51041 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51042 }
51043 {
51044 PyThreadState* __tstate = wxPyBeginAllowThreads();
51045 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51046 wxPyEndAllowThreads(__tstate);
51047 if (PyErr_Occurred()) SWIG_fail;
51048 }
51049 {
51050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51051 }
51052 return resultobj;
51053 fail:
51054 return NULL;
51055 }
51056
51057
51058 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51059 PyObject *resultobj = 0;
51060 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51061 wxSizer *arg2 = (wxSizer *) 0 ;
51062 wxGBSpan *arg3 = 0 ;
51063 bool result;
51064 void *argp1 = 0 ;
51065 int res1 = 0 ;
51066 void *argp2 = 0 ;
51067 int res2 = 0 ;
51068 wxGBSpan temp3 ;
51069
51070 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51072 if (!SWIG_IsOK(res1)) {
51073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51074 }
51075 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51076 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51077 if (!SWIG_IsOK(res2)) {
51078 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51079 }
51080 arg2 = reinterpret_cast< wxSizer * >(argp2);
51081 {
51082 arg3 = &temp3;
51083 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51084 }
51085 {
51086 PyThreadState* __tstate = wxPyBeginAllowThreads();
51087 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51088 wxPyEndAllowThreads(__tstate);
51089 if (PyErr_Occurred()) SWIG_fail;
51090 }
51091 {
51092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51093 }
51094 return resultobj;
51095 fail:
51096 return NULL;
51097 }
51098
51099
51100 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51101 PyObject *resultobj = 0;
51102 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51103 size_t arg2 ;
51104 wxGBSpan *arg3 = 0 ;
51105 bool result;
51106 void *argp1 = 0 ;
51107 int res1 = 0 ;
51108 size_t val2 ;
51109 int ecode2 = 0 ;
51110 wxGBSpan temp3 ;
51111
51112 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51114 if (!SWIG_IsOK(res1)) {
51115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51116 }
51117 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51118 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51119 if (!SWIG_IsOK(ecode2)) {
51120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51121 }
51122 arg2 = static_cast< size_t >(val2);
51123 {
51124 arg3 = &temp3;
51125 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51126 }
51127 {
51128 PyThreadState* __tstate = wxPyBeginAllowThreads();
51129 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51130 wxPyEndAllowThreads(__tstate);
51131 if (PyErr_Occurred()) SWIG_fail;
51132 }
51133 {
51134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51135 }
51136 return resultobj;
51137 fail:
51138 return NULL;
51139 }
51140
51141
51142 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51143 int argc;
51144 PyObject *argv[4];
51145
51146 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51147 --argc;
51148 if (argc == 3) {
51149 int _v = 0;
51150 {
51151 void *vptr = 0;
51152 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51153 _v = SWIG_CheckState(res);
51154 }
51155 if (!_v) goto check_1;
51156 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51157 }
51158 check_1:
51159
51160 if (argc == 3) {
51161 int _v = 0;
51162 {
51163 void *vptr = 0;
51164 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51165 _v = SWIG_CheckState(res);
51166 }
51167 if (!_v) goto check_2;
51168 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51169 }
51170 check_2:
51171
51172 if (argc == 3) {
51173 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51174 }
51175
51176 fail:
51177 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51178 return NULL;
51179 }
51180
51181
51182 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51183 PyObject *resultobj = 0;
51184 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51185 wxWindow *arg2 = (wxWindow *) 0 ;
51186 wxGBSizerItem *result = 0 ;
51187 void *argp1 = 0 ;
51188 int res1 = 0 ;
51189 void *argp2 = 0 ;
51190 int res2 = 0 ;
51191
51192 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51194 if (!SWIG_IsOK(res1)) {
51195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51196 }
51197 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51198 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51199 if (!SWIG_IsOK(res2)) {
51200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51201 }
51202 arg2 = reinterpret_cast< wxWindow * >(argp2);
51203 {
51204 PyThreadState* __tstate = wxPyBeginAllowThreads();
51205 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51206 wxPyEndAllowThreads(__tstate);
51207 if (PyErr_Occurred()) SWIG_fail;
51208 }
51209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51210 return resultobj;
51211 fail:
51212 return NULL;
51213 }
51214
51215
51216 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51217 PyObject *resultobj = 0;
51218 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51219 wxSizer *arg2 = (wxSizer *) 0 ;
51220 wxGBSizerItem *result = 0 ;
51221 void *argp1 = 0 ;
51222 int res1 = 0 ;
51223 void *argp2 = 0 ;
51224 int res2 = 0 ;
51225
51226 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51228 if (!SWIG_IsOK(res1)) {
51229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51230 }
51231 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51232 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51233 if (!SWIG_IsOK(res2)) {
51234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51235 }
51236 arg2 = reinterpret_cast< wxSizer * >(argp2);
51237 {
51238 PyThreadState* __tstate = wxPyBeginAllowThreads();
51239 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51240 wxPyEndAllowThreads(__tstate);
51241 if (PyErr_Occurred()) SWIG_fail;
51242 }
51243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51244 return resultobj;
51245 fail:
51246 return NULL;
51247 }
51248
51249
51250 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51251 int argc;
51252 PyObject *argv[3];
51253
51254 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51255 --argc;
51256 if (argc == 2) {
51257 int _v = 0;
51258 {
51259 void *vptr = 0;
51260 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51261 _v = SWIG_CheckState(res);
51262 }
51263 if (!_v) goto check_1;
51264 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51265 }
51266 check_1:
51267
51268 if (argc == 2) {
51269 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51270 }
51271
51272 fail:
51273 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51274 return NULL;
51275 }
51276
51277
51278 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51279 PyObject *resultobj = 0;
51280 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51281 wxGBPosition *arg2 = 0 ;
51282 wxGBSizerItem *result = 0 ;
51283 void *argp1 = 0 ;
51284 int res1 = 0 ;
51285 wxGBPosition temp2 ;
51286 PyObject * obj0 = 0 ;
51287 PyObject * obj1 = 0 ;
51288 char * kwnames[] = {
51289 (char *) "self",(char *) "pos", NULL
51290 };
51291
51292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51294 if (!SWIG_IsOK(res1)) {
51295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51296 }
51297 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51298 {
51299 arg2 = &temp2;
51300 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51301 }
51302 {
51303 PyThreadState* __tstate = wxPyBeginAllowThreads();
51304 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51305 wxPyEndAllowThreads(__tstate);
51306 if (PyErr_Occurred()) SWIG_fail;
51307 }
51308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51309 return resultobj;
51310 fail:
51311 return NULL;
51312 }
51313
51314
51315 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51316 PyObject *resultobj = 0;
51317 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51318 wxPoint *arg2 = 0 ;
51319 wxGBSizerItem *result = 0 ;
51320 void *argp1 = 0 ;
51321 int res1 = 0 ;
51322 wxPoint temp2 ;
51323 PyObject * obj0 = 0 ;
51324 PyObject * obj1 = 0 ;
51325 char * kwnames[] = {
51326 (char *) "self",(char *) "pt", NULL
51327 };
51328
51329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51331 if (!SWIG_IsOK(res1)) {
51332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51333 }
51334 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51335 {
51336 arg2 = &temp2;
51337 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51338 }
51339 {
51340 PyThreadState* __tstate = wxPyBeginAllowThreads();
51341 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51342 wxPyEndAllowThreads(__tstate);
51343 if (PyErr_Occurred()) SWIG_fail;
51344 }
51345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51346 return resultobj;
51347 fail:
51348 return NULL;
51349 }
51350
51351
51352 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51353 PyObject *resultobj = 0;
51354 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51355 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51356 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51357 bool result;
51358 void *argp1 = 0 ;
51359 int res1 = 0 ;
51360 void *argp2 = 0 ;
51361 int res2 = 0 ;
51362 void *argp3 = 0 ;
51363 int res3 = 0 ;
51364 PyObject * obj0 = 0 ;
51365 PyObject * obj1 = 0 ;
51366 PyObject * obj2 = 0 ;
51367 char * kwnames[] = {
51368 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51369 };
51370
51371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51373 if (!SWIG_IsOK(res1)) {
51374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51375 }
51376 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51378 if (!SWIG_IsOK(res2)) {
51379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51380 }
51381 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51382 if (obj2) {
51383 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51384 if (!SWIG_IsOK(res3)) {
51385 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51386 }
51387 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51388 }
51389 {
51390 PyThreadState* __tstate = wxPyBeginAllowThreads();
51391 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51392 wxPyEndAllowThreads(__tstate);
51393 if (PyErr_Occurred()) SWIG_fail;
51394 }
51395 {
51396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51397 }
51398 return resultobj;
51399 fail:
51400 return NULL;
51401 }
51402
51403
51404 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51405 PyObject *resultobj = 0;
51406 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51407 wxGBPosition *arg2 = 0 ;
51408 wxGBSpan *arg3 = 0 ;
51409 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51410 bool result;
51411 void *argp1 = 0 ;
51412 int res1 = 0 ;
51413 wxGBPosition temp2 ;
51414 wxGBSpan temp3 ;
51415 void *argp4 = 0 ;
51416 int res4 = 0 ;
51417 PyObject * obj0 = 0 ;
51418 PyObject * obj1 = 0 ;
51419 PyObject * obj2 = 0 ;
51420 PyObject * obj3 = 0 ;
51421 char * kwnames[] = {
51422 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51423 };
51424
51425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51427 if (!SWIG_IsOK(res1)) {
51428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51429 }
51430 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51431 {
51432 arg2 = &temp2;
51433 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51434 }
51435 {
51436 arg3 = &temp3;
51437 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51438 }
51439 if (obj3) {
51440 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51441 if (!SWIG_IsOK(res4)) {
51442 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51443 }
51444 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51445 }
51446 {
51447 PyThreadState* __tstate = wxPyBeginAllowThreads();
51448 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51449 wxPyEndAllowThreads(__tstate);
51450 if (PyErr_Occurred()) SWIG_fail;
51451 }
51452 {
51453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51454 }
51455 return resultobj;
51456 fail:
51457 return NULL;
51458 }
51459
51460
51461 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51462 PyObject *obj;
51463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51464 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51465 return SWIG_Py_Void();
51466 }
51467
51468 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51469 return SWIG_Python_InitShadowInstance(args);
51470 }
51471
51472 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51473 PyObject *resultobj = 0;
51474 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51475 wxRelationship arg2 ;
51476 wxWindow *arg3 = (wxWindow *) 0 ;
51477 wxEdge arg4 ;
51478 int arg5 = (int) 0 ;
51479 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51480 void *argp1 = 0 ;
51481 int res1 = 0 ;
51482 int val2 ;
51483 int ecode2 = 0 ;
51484 void *argp3 = 0 ;
51485 int res3 = 0 ;
51486 int val4 ;
51487 int ecode4 = 0 ;
51488 int val5 ;
51489 int ecode5 = 0 ;
51490 int val6 ;
51491 int ecode6 = 0 ;
51492 PyObject * obj0 = 0 ;
51493 PyObject * obj1 = 0 ;
51494 PyObject * obj2 = 0 ;
51495 PyObject * obj3 = 0 ;
51496 PyObject * obj4 = 0 ;
51497 PyObject * obj5 = 0 ;
51498 char * kwnames[] = {
51499 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51500 };
51501
51502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51504 if (!SWIG_IsOK(res1)) {
51505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51506 }
51507 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51508 ecode2 = SWIG_AsVal_int(obj1, &val2);
51509 if (!SWIG_IsOK(ecode2)) {
51510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51511 }
51512 arg2 = static_cast< wxRelationship >(val2);
51513 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51514 if (!SWIG_IsOK(res3)) {
51515 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51516 }
51517 arg3 = reinterpret_cast< wxWindow * >(argp3);
51518 ecode4 = SWIG_AsVal_int(obj3, &val4);
51519 if (!SWIG_IsOK(ecode4)) {
51520 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51521 }
51522 arg4 = static_cast< wxEdge >(val4);
51523 if (obj4) {
51524 ecode5 = SWIG_AsVal_int(obj4, &val5);
51525 if (!SWIG_IsOK(ecode5)) {
51526 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51527 }
51528 arg5 = static_cast< int >(val5);
51529 }
51530 if (obj5) {
51531 ecode6 = SWIG_AsVal_int(obj5, &val6);
51532 if (!SWIG_IsOK(ecode6)) {
51533 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51534 }
51535 arg6 = static_cast< int >(val6);
51536 }
51537 {
51538 PyThreadState* __tstate = wxPyBeginAllowThreads();
51539 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51540 wxPyEndAllowThreads(__tstate);
51541 if (PyErr_Occurred()) SWIG_fail;
51542 }
51543 resultobj = SWIG_Py_Void();
51544 return resultobj;
51545 fail:
51546 return NULL;
51547 }
51548
51549
51550 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51551 PyObject *resultobj = 0;
51552 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51553 wxWindow *arg2 = (wxWindow *) 0 ;
51554 int arg3 = (int) 0 ;
51555 void *argp1 = 0 ;
51556 int res1 = 0 ;
51557 void *argp2 = 0 ;
51558 int res2 = 0 ;
51559 int val3 ;
51560 int ecode3 = 0 ;
51561 PyObject * obj0 = 0 ;
51562 PyObject * obj1 = 0 ;
51563 PyObject * obj2 = 0 ;
51564 char * kwnames[] = {
51565 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51566 };
51567
51568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51570 if (!SWIG_IsOK(res1)) {
51571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51572 }
51573 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51574 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51575 if (!SWIG_IsOK(res2)) {
51576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51577 }
51578 arg2 = reinterpret_cast< wxWindow * >(argp2);
51579 if (obj2) {
51580 ecode3 = SWIG_AsVal_int(obj2, &val3);
51581 if (!SWIG_IsOK(ecode3)) {
51582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51583 }
51584 arg3 = static_cast< int >(val3);
51585 }
51586 {
51587 PyThreadState* __tstate = wxPyBeginAllowThreads();
51588 (arg1)->LeftOf(arg2,arg3);
51589 wxPyEndAllowThreads(__tstate);
51590 if (PyErr_Occurred()) SWIG_fail;
51591 }
51592 resultobj = SWIG_Py_Void();
51593 return resultobj;
51594 fail:
51595 return NULL;
51596 }
51597
51598
51599 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51600 PyObject *resultobj = 0;
51601 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51602 wxWindow *arg2 = (wxWindow *) 0 ;
51603 int arg3 = (int) 0 ;
51604 void *argp1 = 0 ;
51605 int res1 = 0 ;
51606 void *argp2 = 0 ;
51607 int res2 = 0 ;
51608 int val3 ;
51609 int ecode3 = 0 ;
51610 PyObject * obj0 = 0 ;
51611 PyObject * obj1 = 0 ;
51612 PyObject * obj2 = 0 ;
51613 char * kwnames[] = {
51614 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51615 };
51616
51617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51619 if (!SWIG_IsOK(res1)) {
51620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51621 }
51622 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51623 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51624 if (!SWIG_IsOK(res2)) {
51625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51626 }
51627 arg2 = reinterpret_cast< wxWindow * >(argp2);
51628 if (obj2) {
51629 ecode3 = SWIG_AsVal_int(obj2, &val3);
51630 if (!SWIG_IsOK(ecode3)) {
51631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51632 }
51633 arg3 = static_cast< int >(val3);
51634 }
51635 {
51636 PyThreadState* __tstate = wxPyBeginAllowThreads();
51637 (arg1)->RightOf(arg2,arg3);
51638 wxPyEndAllowThreads(__tstate);
51639 if (PyErr_Occurred()) SWIG_fail;
51640 }
51641 resultobj = SWIG_Py_Void();
51642 return resultobj;
51643 fail:
51644 return NULL;
51645 }
51646
51647
51648 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51649 PyObject *resultobj = 0;
51650 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51651 wxWindow *arg2 = (wxWindow *) 0 ;
51652 int arg3 = (int) 0 ;
51653 void *argp1 = 0 ;
51654 int res1 = 0 ;
51655 void *argp2 = 0 ;
51656 int res2 = 0 ;
51657 int val3 ;
51658 int ecode3 = 0 ;
51659 PyObject * obj0 = 0 ;
51660 PyObject * obj1 = 0 ;
51661 PyObject * obj2 = 0 ;
51662 char * kwnames[] = {
51663 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51664 };
51665
51666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51668 if (!SWIG_IsOK(res1)) {
51669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51670 }
51671 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51672 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51673 if (!SWIG_IsOK(res2)) {
51674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51675 }
51676 arg2 = reinterpret_cast< wxWindow * >(argp2);
51677 if (obj2) {
51678 ecode3 = SWIG_AsVal_int(obj2, &val3);
51679 if (!SWIG_IsOK(ecode3)) {
51680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51681 }
51682 arg3 = static_cast< int >(val3);
51683 }
51684 {
51685 PyThreadState* __tstate = wxPyBeginAllowThreads();
51686 (arg1)->Above(arg2,arg3);
51687 wxPyEndAllowThreads(__tstate);
51688 if (PyErr_Occurred()) SWIG_fail;
51689 }
51690 resultobj = SWIG_Py_Void();
51691 return resultobj;
51692 fail:
51693 return NULL;
51694 }
51695
51696
51697 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51698 PyObject *resultobj = 0;
51699 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51700 wxWindow *arg2 = (wxWindow *) 0 ;
51701 int arg3 = (int) 0 ;
51702 void *argp1 = 0 ;
51703 int res1 = 0 ;
51704 void *argp2 = 0 ;
51705 int res2 = 0 ;
51706 int val3 ;
51707 int ecode3 = 0 ;
51708 PyObject * obj0 = 0 ;
51709 PyObject * obj1 = 0 ;
51710 PyObject * obj2 = 0 ;
51711 char * kwnames[] = {
51712 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51713 };
51714
51715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51717 if (!SWIG_IsOK(res1)) {
51718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51719 }
51720 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51721 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51722 if (!SWIG_IsOK(res2)) {
51723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51724 }
51725 arg2 = reinterpret_cast< wxWindow * >(argp2);
51726 if (obj2) {
51727 ecode3 = SWIG_AsVal_int(obj2, &val3);
51728 if (!SWIG_IsOK(ecode3)) {
51729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51730 }
51731 arg3 = static_cast< int >(val3);
51732 }
51733 {
51734 PyThreadState* __tstate = wxPyBeginAllowThreads();
51735 (arg1)->Below(arg2,arg3);
51736 wxPyEndAllowThreads(__tstate);
51737 if (PyErr_Occurred()) SWIG_fail;
51738 }
51739 resultobj = SWIG_Py_Void();
51740 return resultobj;
51741 fail:
51742 return NULL;
51743 }
51744
51745
51746 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51747 PyObject *resultobj = 0;
51748 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51749 wxWindow *arg2 = (wxWindow *) 0 ;
51750 wxEdge arg3 ;
51751 int arg4 = (int) 0 ;
51752 void *argp1 = 0 ;
51753 int res1 = 0 ;
51754 void *argp2 = 0 ;
51755 int res2 = 0 ;
51756 int val3 ;
51757 int ecode3 = 0 ;
51758 int val4 ;
51759 int ecode4 = 0 ;
51760 PyObject * obj0 = 0 ;
51761 PyObject * obj1 = 0 ;
51762 PyObject * obj2 = 0 ;
51763 PyObject * obj3 = 0 ;
51764 char * kwnames[] = {
51765 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51766 };
51767
51768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51770 if (!SWIG_IsOK(res1)) {
51771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51772 }
51773 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51774 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51775 if (!SWIG_IsOK(res2)) {
51776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51777 }
51778 arg2 = reinterpret_cast< wxWindow * >(argp2);
51779 ecode3 = SWIG_AsVal_int(obj2, &val3);
51780 if (!SWIG_IsOK(ecode3)) {
51781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51782 }
51783 arg3 = static_cast< wxEdge >(val3);
51784 if (obj3) {
51785 ecode4 = SWIG_AsVal_int(obj3, &val4);
51786 if (!SWIG_IsOK(ecode4)) {
51787 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51788 }
51789 arg4 = static_cast< int >(val4);
51790 }
51791 {
51792 PyThreadState* __tstate = wxPyBeginAllowThreads();
51793 (arg1)->SameAs(arg2,arg3,arg4);
51794 wxPyEndAllowThreads(__tstate);
51795 if (PyErr_Occurred()) SWIG_fail;
51796 }
51797 resultobj = SWIG_Py_Void();
51798 return resultobj;
51799 fail:
51800 return NULL;
51801 }
51802
51803
51804 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51805 PyObject *resultobj = 0;
51806 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51807 wxWindow *arg2 = (wxWindow *) 0 ;
51808 wxEdge arg3 ;
51809 int arg4 ;
51810 void *argp1 = 0 ;
51811 int res1 = 0 ;
51812 void *argp2 = 0 ;
51813 int res2 = 0 ;
51814 int val3 ;
51815 int ecode3 = 0 ;
51816 int val4 ;
51817 int ecode4 = 0 ;
51818 PyObject * obj0 = 0 ;
51819 PyObject * obj1 = 0 ;
51820 PyObject * obj2 = 0 ;
51821 PyObject * obj3 = 0 ;
51822 char * kwnames[] = {
51823 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51824 };
51825
51826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51828 if (!SWIG_IsOK(res1)) {
51829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51830 }
51831 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51832 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51833 if (!SWIG_IsOK(res2)) {
51834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51835 }
51836 arg2 = reinterpret_cast< wxWindow * >(argp2);
51837 ecode3 = SWIG_AsVal_int(obj2, &val3);
51838 if (!SWIG_IsOK(ecode3)) {
51839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51840 }
51841 arg3 = static_cast< wxEdge >(val3);
51842 ecode4 = SWIG_AsVal_int(obj3, &val4);
51843 if (!SWIG_IsOK(ecode4)) {
51844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51845 }
51846 arg4 = static_cast< int >(val4);
51847 {
51848 PyThreadState* __tstate = wxPyBeginAllowThreads();
51849 (arg1)->PercentOf(arg2,arg3,arg4);
51850 wxPyEndAllowThreads(__tstate);
51851 if (PyErr_Occurred()) SWIG_fail;
51852 }
51853 resultobj = SWIG_Py_Void();
51854 return resultobj;
51855 fail:
51856 return NULL;
51857 }
51858
51859
51860 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51861 PyObject *resultobj = 0;
51862 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51863 int arg2 ;
51864 void *argp1 = 0 ;
51865 int res1 = 0 ;
51866 int val2 ;
51867 int ecode2 = 0 ;
51868 PyObject * obj0 = 0 ;
51869 PyObject * obj1 = 0 ;
51870 char * kwnames[] = {
51871 (char *) "self",(char *) "val", NULL
51872 };
51873
51874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51876 if (!SWIG_IsOK(res1)) {
51877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51878 }
51879 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51880 ecode2 = SWIG_AsVal_int(obj1, &val2);
51881 if (!SWIG_IsOK(ecode2)) {
51882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51883 }
51884 arg2 = static_cast< int >(val2);
51885 {
51886 PyThreadState* __tstate = wxPyBeginAllowThreads();
51887 (arg1)->Absolute(arg2);
51888 wxPyEndAllowThreads(__tstate);
51889 if (PyErr_Occurred()) SWIG_fail;
51890 }
51891 resultobj = SWIG_Py_Void();
51892 return resultobj;
51893 fail:
51894 return NULL;
51895 }
51896
51897
51898 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51899 PyObject *resultobj = 0;
51900 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51901 void *argp1 = 0 ;
51902 int res1 = 0 ;
51903 PyObject *swig_obj[1] ;
51904
51905 if (!args) SWIG_fail;
51906 swig_obj[0] = args;
51907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51908 if (!SWIG_IsOK(res1)) {
51909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51910 }
51911 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51912 {
51913 PyThreadState* __tstate = wxPyBeginAllowThreads();
51914 (arg1)->Unconstrained();
51915 wxPyEndAllowThreads(__tstate);
51916 if (PyErr_Occurred()) SWIG_fail;
51917 }
51918 resultobj = SWIG_Py_Void();
51919 return resultobj;
51920 fail:
51921 return NULL;
51922 }
51923
51924
51925 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51926 PyObject *resultobj = 0;
51927 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51928 void *argp1 = 0 ;
51929 int res1 = 0 ;
51930 PyObject *swig_obj[1] ;
51931
51932 if (!args) SWIG_fail;
51933 swig_obj[0] = args;
51934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51935 if (!SWIG_IsOK(res1)) {
51936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51937 }
51938 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51939 {
51940 PyThreadState* __tstate = wxPyBeginAllowThreads();
51941 (arg1)->AsIs();
51942 wxPyEndAllowThreads(__tstate);
51943 if (PyErr_Occurred()) SWIG_fail;
51944 }
51945 resultobj = SWIG_Py_Void();
51946 return resultobj;
51947 fail:
51948 return NULL;
51949 }
51950
51951
51952 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51953 PyObject *resultobj = 0;
51954 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51955 wxWindow *result = 0 ;
51956 void *argp1 = 0 ;
51957 int res1 = 0 ;
51958 PyObject *swig_obj[1] ;
51959
51960 if (!args) SWIG_fail;
51961 swig_obj[0] = args;
51962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51963 if (!SWIG_IsOK(res1)) {
51964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51965 }
51966 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51967 {
51968 PyThreadState* __tstate = wxPyBeginAllowThreads();
51969 result = (wxWindow *)(arg1)->GetOtherWindow();
51970 wxPyEndAllowThreads(__tstate);
51971 if (PyErr_Occurred()) SWIG_fail;
51972 }
51973 {
51974 resultobj = wxPyMake_wxObject(result, 0);
51975 }
51976 return resultobj;
51977 fail:
51978 return NULL;
51979 }
51980
51981
51982 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51983 PyObject *resultobj = 0;
51984 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51985 wxEdge result;
51986 void *argp1 = 0 ;
51987 int res1 = 0 ;
51988 PyObject *swig_obj[1] ;
51989
51990 if (!args) SWIG_fail;
51991 swig_obj[0] = args;
51992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51993 if (!SWIG_IsOK(res1)) {
51994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51995 }
51996 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51997 {
51998 PyThreadState* __tstate = wxPyBeginAllowThreads();
51999 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52000 wxPyEndAllowThreads(__tstate);
52001 if (PyErr_Occurred()) SWIG_fail;
52002 }
52003 resultobj = SWIG_From_int(static_cast< int >(result));
52004 return resultobj;
52005 fail:
52006 return NULL;
52007 }
52008
52009
52010 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52011 PyObject *resultobj = 0;
52012 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52013 wxEdge arg2 ;
52014 void *argp1 = 0 ;
52015 int res1 = 0 ;
52016 int val2 ;
52017 int ecode2 = 0 ;
52018 PyObject * obj0 = 0 ;
52019 PyObject * obj1 = 0 ;
52020 char * kwnames[] = {
52021 (char *) "self",(char *) "which", NULL
52022 };
52023
52024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52026 if (!SWIG_IsOK(res1)) {
52027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52028 }
52029 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52030 ecode2 = SWIG_AsVal_int(obj1, &val2);
52031 if (!SWIG_IsOK(ecode2)) {
52032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52033 }
52034 arg2 = static_cast< wxEdge >(val2);
52035 {
52036 PyThreadState* __tstate = wxPyBeginAllowThreads();
52037 (arg1)->SetEdge(arg2);
52038 wxPyEndAllowThreads(__tstate);
52039 if (PyErr_Occurred()) SWIG_fail;
52040 }
52041 resultobj = SWIG_Py_Void();
52042 return resultobj;
52043 fail:
52044 return NULL;
52045 }
52046
52047
52048 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52049 PyObject *resultobj = 0;
52050 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52051 int arg2 ;
52052 void *argp1 = 0 ;
52053 int res1 = 0 ;
52054 int val2 ;
52055 int ecode2 = 0 ;
52056 PyObject * obj0 = 0 ;
52057 PyObject * obj1 = 0 ;
52058 char * kwnames[] = {
52059 (char *) "self",(char *) "v", NULL
52060 };
52061
52062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52064 if (!SWIG_IsOK(res1)) {
52065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52066 }
52067 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52068 ecode2 = SWIG_AsVal_int(obj1, &val2);
52069 if (!SWIG_IsOK(ecode2)) {
52070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52071 }
52072 arg2 = static_cast< int >(val2);
52073 {
52074 PyThreadState* __tstate = wxPyBeginAllowThreads();
52075 (arg1)->SetValue(arg2);
52076 wxPyEndAllowThreads(__tstate);
52077 if (PyErr_Occurred()) SWIG_fail;
52078 }
52079 resultobj = SWIG_Py_Void();
52080 return resultobj;
52081 fail:
52082 return NULL;
52083 }
52084
52085
52086 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52087 PyObject *resultobj = 0;
52088 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52089 int result;
52090 void *argp1 = 0 ;
52091 int res1 = 0 ;
52092 PyObject *swig_obj[1] ;
52093
52094 if (!args) SWIG_fail;
52095 swig_obj[0] = args;
52096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52097 if (!SWIG_IsOK(res1)) {
52098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52099 }
52100 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52101 {
52102 PyThreadState* __tstate = wxPyBeginAllowThreads();
52103 result = (int)(arg1)->GetMargin();
52104 wxPyEndAllowThreads(__tstate);
52105 if (PyErr_Occurred()) SWIG_fail;
52106 }
52107 resultobj = SWIG_From_int(static_cast< int >(result));
52108 return resultobj;
52109 fail:
52110 return NULL;
52111 }
52112
52113
52114 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52115 PyObject *resultobj = 0;
52116 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52117 int arg2 ;
52118 void *argp1 = 0 ;
52119 int res1 = 0 ;
52120 int val2 ;
52121 int ecode2 = 0 ;
52122 PyObject * obj0 = 0 ;
52123 PyObject * obj1 = 0 ;
52124 char * kwnames[] = {
52125 (char *) "self",(char *) "m", NULL
52126 };
52127
52128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52130 if (!SWIG_IsOK(res1)) {
52131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52132 }
52133 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52134 ecode2 = SWIG_AsVal_int(obj1, &val2);
52135 if (!SWIG_IsOK(ecode2)) {
52136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52137 }
52138 arg2 = static_cast< int >(val2);
52139 {
52140 PyThreadState* __tstate = wxPyBeginAllowThreads();
52141 (arg1)->SetMargin(arg2);
52142 wxPyEndAllowThreads(__tstate);
52143 if (PyErr_Occurred()) SWIG_fail;
52144 }
52145 resultobj = SWIG_Py_Void();
52146 return resultobj;
52147 fail:
52148 return NULL;
52149 }
52150
52151
52152 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52153 PyObject *resultobj = 0;
52154 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52155 int result;
52156 void *argp1 = 0 ;
52157 int res1 = 0 ;
52158 PyObject *swig_obj[1] ;
52159
52160 if (!args) SWIG_fail;
52161 swig_obj[0] = args;
52162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52163 if (!SWIG_IsOK(res1)) {
52164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52165 }
52166 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52167 {
52168 PyThreadState* __tstate = wxPyBeginAllowThreads();
52169 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52170 wxPyEndAllowThreads(__tstate);
52171 if (PyErr_Occurred()) SWIG_fail;
52172 }
52173 resultobj = SWIG_From_int(static_cast< int >(result));
52174 return resultobj;
52175 fail:
52176 return NULL;
52177 }
52178
52179
52180 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52181 PyObject *resultobj = 0;
52182 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52183 int result;
52184 void *argp1 = 0 ;
52185 int res1 = 0 ;
52186 PyObject *swig_obj[1] ;
52187
52188 if (!args) SWIG_fail;
52189 swig_obj[0] = args;
52190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52191 if (!SWIG_IsOK(res1)) {
52192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52193 }
52194 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52195 {
52196 PyThreadState* __tstate = wxPyBeginAllowThreads();
52197 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52198 wxPyEndAllowThreads(__tstate);
52199 if (PyErr_Occurred()) SWIG_fail;
52200 }
52201 resultobj = SWIG_From_int(static_cast< int >(result));
52202 return resultobj;
52203 fail:
52204 return NULL;
52205 }
52206
52207
52208 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52209 PyObject *resultobj = 0;
52210 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52211 int result;
52212 void *argp1 = 0 ;
52213 int res1 = 0 ;
52214 PyObject *swig_obj[1] ;
52215
52216 if (!args) SWIG_fail;
52217 swig_obj[0] = args;
52218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52219 if (!SWIG_IsOK(res1)) {
52220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52221 }
52222 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52223 {
52224 PyThreadState* __tstate = wxPyBeginAllowThreads();
52225 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52226 wxPyEndAllowThreads(__tstate);
52227 if (PyErr_Occurred()) SWIG_fail;
52228 }
52229 resultobj = SWIG_From_int(static_cast< int >(result));
52230 return resultobj;
52231 fail:
52232 return NULL;
52233 }
52234
52235
52236 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52237 PyObject *resultobj = 0;
52238 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52239 bool result;
52240 void *argp1 = 0 ;
52241 int res1 = 0 ;
52242 PyObject *swig_obj[1] ;
52243
52244 if (!args) SWIG_fail;
52245 swig_obj[0] = args;
52246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52247 if (!SWIG_IsOK(res1)) {
52248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52249 }
52250 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52251 {
52252 PyThreadState* __tstate = wxPyBeginAllowThreads();
52253 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52254 wxPyEndAllowThreads(__tstate);
52255 if (PyErr_Occurred()) SWIG_fail;
52256 }
52257 {
52258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52259 }
52260 return resultobj;
52261 fail:
52262 return NULL;
52263 }
52264
52265
52266 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52267 PyObject *resultobj = 0;
52268 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52269 bool arg2 ;
52270 void *argp1 = 0 ;
52271 int res1 = 0 ;
52272 bool val2 ;
52273 int ecode2 = 0 ;
52274 PyObject * obj0 = 0 ;
52275 PyObject * obj1 = 0 ;
52276 char * kwnames[] = {
52277 (char *) "self",(char *) "d", NULL
52278 };
52279
52280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52282 if (!SWIG_IsOK(res1)) {
52283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52284 }
52285 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52286 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52287 if (!SWIG_IsOK(ecode2)) {
52288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52289 }
52290 arg2 = static_cast< bool >(val2);
52291 {
52292 PyThreadState* __tstate = wxPyBeginAllowThreads();
52293 (arg1)->SetDone(arg2);
52294 wxPyEndAllowThreads(__tstate);
52295 if (PyErr_Occurred()) SWIG_fail;
52296 }
52297 resultobj = SWIG_Py_Void();
52298 return resultobj;
52299 fail:
52300 return NULL;
52301 }
52302
52303
52304 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52305 PyObject *resultobj = 0;
52306 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52307 wxRelationship result;
52308 void *argp1 = 0 ;
52309 int res1 = 0 ;
52310 PyObject *swig_obj[1] ;
52311
52312 if (!args) SWIG_fail;
52313 swig_obj[0] = args;
52314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52315 if (!SWIG_IsOK(res1)) {
52316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52317 }
52318 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52319 {
52320 PyThreadState* __tstate = wxPyBeginAllowThreads();
52321 result = (wxRelationship)(arg1)->GetRelationship();
52322 wxPyEndAllowThreads(__tstate);
52323 if (PyErr_Occurred()) SWIG_fail;
52324 }
52325 resultobj = SWIG_From_int(static_cast< int >(result));
52326 return resultobj;
52327 fail:
52328 return NULL;
52329 }
52330
52331
52332 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52333 PyObject *resultobj = 0;
52334 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52335 wxRelationship arg2 ;
52336 void *argp1 = 0 ;
52337 int res1 = 0 ;
52338 int val2 ;
52339 int ecode2 = 0 ;
52340 PyObject * obj0 = 0 ;
52341 PyObject * obj1 = 0 ;
52342 char * kwnames[] = {
52343 (char *) "self",(char *) "r", NULL
52344 };
52345
52346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52348 if (!SWIG_IsOK(res1)) {
52349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52350 }
52351 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52352 ecode2 = SWIG_AsVal_int(obj1, &val2);
52353 if (!SWIG_IsOK(ecode2)) {
52354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52355 }
52356 arg2 = static_cast< wxRelationship >(val2);
52357 {
52358 PyThreadState* __tstate = wxPyBeginAllowThreads();
52359 (arg1)->SetRelationship(arg2);
52360 wxPyEndAllowThreads(__tstate);
52361 if (PyErr_Occurred()) SWIG_fail;
52362 }
52363 resultobj = SWIG_Py_Void();
52364 return resultobj;
52365 fail:
52366 return NULL;
52367 }
52368
52369
52370 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52371 PyObject *resultobj = 0;
52372 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52373 wxWindow *arg2 = (wxWindow *) 0 ;
52374 bool result;
52375 void *argp1 = 0 ;
52376 int res1 = 0 ;
52377 void *argp2 = 0 ;
52378 int res2 = 0 ;
52379 PyObject * obj0 = 0 ;
52380 PyObject * obj1 = 0 ;
52381 char * kwnames[] = {
52382 (char *) "self",(char *) "otherW", NULL
52383 };
52384
52385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52387 if (!SWIG_IsOK(res1)) {
52388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52389 }
52390 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52391 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52392 if (!SWIG_IsOK(res2)) {
52393 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52394 }
52395 arg2 = reinterpret_cast< wxWindow * >(argp2);
52396 {
52397 PyThreadState* __tstate = wxPyBeginAllowThreads();
52398 result = (bool)(arg1)->ResetIfWin(arg2);
52399 wxPyEndAllowThreads(__tstate);
52400 if (PyErr_Occurred()) SWIG_fail;
52401 }
52402 {
52403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52404 }
52405 return resultobj;
52406 fail:
52407 return NULL;
52408 }
52409
52410
52411 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52412 PyObject *resultobj = 0;
52413 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52414 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52415 wxWindow *arg3 = (wxWindow *) 0 ;
52416 bool result;
52417 void *argp1 = 0 ;
52418 int res1 = 0 ;
52419 void *argp2 = 0 ;
52420 int res2 = 0 ;
52421 void *argp3 = 0 ;
52422 int res3 = 0 ;
52423 PyObject * obj0 = 0 ;
52424 PyObject * obj1 = 0 ;
52425 PyObject * obj2 = 0 ;
52426 char * kwnames[] = {
52427 (char *) "self",(char *) "constraints",(char *) "win", NULL
52428 };
52429
52430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52432 if (!SWIG_IsOK(res1)) {
52433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52434 }
52435 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52436 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52437 if (!SWIG_IsOK(res2)) {
52438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52439 }
52440 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52441 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52442 if (!SWIG_IsOK(res3)) {
52443 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52444 }
52445 arg3 = reinterpret_cast< wxWindow * >(argp3);
52446 {
52447 PyThreadState* __tstate = wxPyBeginAllowThreads();
52448 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52449 wxPyEndAllowThreads(__tstate);
52450 if (PyErr_Occurred()) SWIG_fail;
52451 }
52452 {
52453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52454 }
52455 return resultobj;
52456 fail:
52457 return NULL;
52458 }
52459
52460
52461 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52462 PyObject *resultobj = 0;
52463 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52464 wxEdge arg2 ;
52465 wxWindow *arg3 = (wxWindow *) 0 ;
52466 wxWindow *arg4 = (wxWindow *) 0 ;
52467 int result;
52468 void *argp1 = 0 ;
52469 int res1 = 0 ;
52470 int val2 ;
52471 int ecode2 = 0 ;
52472 void *argp3 = 0 ;
52473 int res3 = 0 ;
52474 void *argp4 = 0 ;
52475 int res4 = 0 ;
52476 PyObject * obj0 = 0 ;
52477 PyObject * obj1 = 0 ;
52478 PyObject * obj2 = 0 ;
52479 PyObject * obj3 = 0 ;
52480 char * kwnames[] = {
52481 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52482 };
52483
52484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52486 if (!SWIG_IsOK(res1)) {
52487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52488 }
52489 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52490 ecode2 = SWIG_AsVal_int(obj1, &val2);
52491 if (!SWIG_IsOK(ecode2)) {
52492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52493 }
52494 arg2 = static_cast< wxEdge >(val2);
52495 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52496 if (!SWIG_IsOK(res3)) {
52497 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52498 }
52499 arg3 = reinterpret_cast< wxWindow * >(argp3);
52500 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52501 if (!SWIG_IsOK(res4)) {
52502 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52503 }
52504 arg4 = reinterpret_cast< wxWindow * >(argp4);
52505 {
52506 PyThreadState* __tstate = wxPyBeginAllowThreads();
52507 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52508 wxPyEndAllowThreads(__tstate);
52509 if (PyErr_Occurred()) SWIG_fail;
52510 }
52511 resultobj = SWIG_From_int(static_cast< int >(result));
52512 return resultobj;
52513 fail:
52514 return NULL;
52515 }
52516
52517
52518 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52519 PyObject *obj;
52520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52521 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52522 return SWIG_Py_Void();
52523 }
52524
52525 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52526 PyObject *resultobj = 0;
52527 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52528 wxIndividualLayoutConstraint *result = 0 ;
52529 void *argp1 = 0 ;
52530 int res1 = 0 ;
52531 PyObject *swig_obj[1] ;
52532
52533 if (!args) SWIG_fail;
52534 swig_obj[0] = args;
52535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52536 if (!SWIG_IsOK(res1)) {
52537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52538 }
52539 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52540 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52542 return resultobj;
52543 fail:
52544 return NULL;
52545 }
52546
52547
52548 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52549 PyObject *resultobj = 0;
52550 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52551 wxIndividualLayoutConstraint *result = 0 ;
52552 void *argp1 = 0 ;
52553 int res1 = 0 ;
52554 PyObject *swig_obj[1] ;
52555
52556 if (!args) SWIG_fail;
52557 swig_obj[0] = args;
52558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52559 if (!SWIG_IsOK(res1)) {
52560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52561 }
52562 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52563 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52565 return resultobj;
52566 fail:
52567 return NULL;
52568 }
52569
52570
52571 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52572 PyObject *resultobj = 0;
52573 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52574 wxIndividualLayoutConstraint *result = 0 ;
52575 void *argp1 = 0 ;
52576 int res1 = 0 ;
52577 PyObject *swig_obj[1] ;
52578
52579 if (!args) SWIG_fail;
52580 swig_obj[0] = args;
52581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52582 if (!SWIG_IsOK(res1)) {
52583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52584 }
52585 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52586 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52588 return resultobj;
52589 fail:
52590 return NULL;
52591 }
52592
52593
52594 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52595 PyObject *resultobj = 0;
52596 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52597 wxIndividualLayoutConstraint *result = 0 ;
52598 void *argp1 = 0 ;
52599 int res1 = 0 ;
52600 PyObject *swig_obj[1] ;
52601
52602 if (!args) SWIG_fail;
52603 swig_obj[0] = args;
52604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52605 if (!SWIG_IsOK(res1)) {
52606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52607 }
52608 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52609 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52611 return resultobj;
52612 fail:
52613 return NULL;
52614 }
52615
52616
52617 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52618 PyObject *resultobj = 0;
52619 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52620 wxIndividualLayoutConstraint *result = 0 ;
52621 void *argp1 = 0 ;
52622 int res1 = 0 ;
52623 PyObject *swig_obj[1] ;
52624
52625 if (!args) SWIG_fail;
52626 swig_obj[0] = args;
52627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52628 if (!SWIG_IsOK(res1)) {
52629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52630 }
52631 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52632 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52634 return resultobj;
52635 fail:
52636 return NULL;
52637 }
52638
52639
52640 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52641 PyObject *resultobj = 0;
52642 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52643 wxIndividualLayoutConstraint *result = 0 ;
52644 void *argp1 = 0 ;
52645 int res1 = 0 ;
52646 PyObject *swig_obj[1] ;
52647
52648 if (!args) SWIG_fail;
52649 swig_obj[0] = args;
52650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52651 if (!SWIG_IsOK(res1)) {
52652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52653 }
52654 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52655 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52657 return resultobj;
52658 fail:
52659 return NULL;
52660 }
52661
52662
52663 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52664 PyObject *resultobj = 0;
52665 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52666 wxIndividualLayoutConstraint *result = 0 ;
52667 void *argp1 = 0 ;
52668 int res1 = 0 ;
52669 PyObject *swig_obj[1] ;
52670
52671 if (!args) SWIG_fail;
52672 swig_obj[0] = args;
52673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52674 if (!SWIG_IsOK(res1)) {
52675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52676 }
52677 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52678 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52680 return resultobj;
52681 fail:
52682 return NULL;
52683 }
52684
52685
52686 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52687 PyObject *resultobj = 0;
52688 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52689 wxIndividualLayoutConstraint *result = 0 ;
52690 void *argp1 = 0 ;
52691 int res1 = 0 ;
52692 PyObject *swig_obj[1] ;
52693
52694 if (!args) SWIG_fail;
52695 swig_obj[0] = args;
52696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52697 if (!SWIG_IsOK(res1)) {
52698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52699 }
52700 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52701 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52703 return resultobj;
52704 fail:
52705 return NULL;
52706 }
52707
52708
52709 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52710 PyObject *resultobj = 0;
52711 wxLayoutConstraints *result = 0 ;
52712
52713 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52714 {
52715 PyThreadState* __tstate = wxPyBeginAllowThreads();
52716 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52717 wxPyEndAllowThreads(__tstate);
52718 if (PyErr_Occurred()) SWIG_fail;
52719 }
52720 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52721 return resultobj;
52722 fail:
52723 return NULL;
52724 }
52725
52726
52727 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52728 PyObject *resultobj = 0;
52729 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52730 void *argp1 = 0 ;
52731 int res1 = 0 ;
52732 PyObject *swig_obj[1] ;
52733
52734 if (!args) SWIG_fail;
52735 swig_obj[0] = args;
52736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52737 if (!SWIG_IsOK(res1)) {
52738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52739 }
52740 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52741 {
52742 PyThreadState* __tstate = wxPyBeginAllowThreads();
52743 delete arg1;
52744
52745 wxPyEndAllowThreads(__tstate);
52746 if (PyErr_Occurred()) SWIG_fail;
52747 }
52748 resultobj = SWIG_Py_Void();
52749 return resultobj;
52750 fail:
52751 return NULL;
52752 }
52753
52754
52755 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52756 PyObject *resultobj = 0;
52757 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52758 wxWindow *arg2 = (wxWindow *) 0 ;
52759 int *arg3 = (int *) 0 ;
52760 bool result;
52761 void *argp1 = 0 ;
52762 int res1 = 0 ;
52763 void *argp2 = 0 ;
52764 int res2 = 0 ;
52765 int temp3 ;
52766 int res3 = SWIG_TMPOBJ ;
52767 PyObject * obj0 = 0 ;
52768 PyObject * obj1 = 0 ;
52769 char * kwnames[] = {
52770 (char *) "self",(char *) "win", NULL
52771 };
52772
52773 arg3 = &temp3;
52774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52776 if (!SWIG_IsOK(res1)) {
52777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52778 }
52779 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52780 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52781 if (!SWIG_IsOK(res2)) {
52782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52783 }
52784 arg2 = reinterpret_cast< wxWindow * >(argp2);
52785 {
52786 PyThreadState* __tstate = wxPyBeginAllowThreads();
52787 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52788 wxPyEndAllowThreads(__tstate);
52789 if (PyErr_Occurred()) SWIG_fail;
52790 }
52791 {
52792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52793 }
52794 if (SWIG_IsTmpObj(res3)) {
52795 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52796 } else {
52797 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52798 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52799 }
52800 return resultobj;
52801 fail:
52802 return NULL;
52803 }
52804
52805
52806 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52807 PyObject *resultobj = 0;
52808 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52809 bool result;
52810 void *argp1 = 0 ;
52811 int res1 = 0 ;
52812 PyObject *swig_obj[1] ;
52813
52814 if (!args) SWIG_fail;
52815 swig_obj[0] = args;
52816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52817 if (!SWIG_IsOK(res1)) {
52818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52819 }
52820 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52821 {
52822 PyThreadState* __tstate = wxPyBeginAllowThreads();
52823 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52824 wxPyEndAllowThreads(__tstate);
52825 if (PyErr_Occurred()) SWIG_fail;
52826 }
52827 {
52828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52829 }
52830 return resultobj;
52831 fail:
52832 return NULL;
52833 }
52834
52835
52836 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52837 PyObject *obj;
52838 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52839 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52840 return SWIG_Py_Void();
52841 }
52842
52843 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52844 return SWIG_Python_InitShadowInstance(args);
52845 }
52846
52847 static PyMethodDef SwigMethods[] = {
52848 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52849 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52850 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52851 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52852 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52853 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52854 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52855 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52856 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52857 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52858 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52864 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52867 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52868 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52869 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52870 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52871 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52873 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52874 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52875 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52876 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52877 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52878 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52879 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52881 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52883 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52884 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52887 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52888 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52889 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52890 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52891 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52892 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52893 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52894 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52895 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52896 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52897 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52898 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52900 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52901 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52902 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52903 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52904 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52905 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52909 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52910 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52911 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52913 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52915 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52916 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52917 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52919 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52921 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52923 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52924 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52925 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52926 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52928 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52929 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52930 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52931 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52933 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52934 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52940 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52943 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52946 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52947 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52950 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52951 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52952 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52953 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52954 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52955 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52956 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52957 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52959 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52960 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52961 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52963 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52964 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52966 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52967 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52968 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52969 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52970 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52971 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52972 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52973 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52974 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52975 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52976 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52977 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52978 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52979 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52980 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52982 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52983 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52984 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52985 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52986 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52988 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52989 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52990 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52991 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52992 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52993 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52994 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52995 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52996 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52998 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53000 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53001 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53002 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53003 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53004 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53005 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53008 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53009 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53010 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53012 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53013 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53015 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53016 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53017 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53018 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53019 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53020 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53021 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53022 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53023 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53024 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53025 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53028 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53029 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53030 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53035 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53036 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53037 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53038 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53039 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53040 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53041 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53042 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53044 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53045 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53046 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53047 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53048 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53049 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53050 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53051 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53054 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53055 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53056 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53060 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53061 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53062 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53064 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53066 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53067 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53071 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53072 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53073 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53074 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53075 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53076 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53077 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53080 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53081 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53082 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53083 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53084 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53085 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53087 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53088 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53089 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53091 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53095 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53096 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53098 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53099 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53100 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53101 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53102 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53103 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53104 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53105 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53106 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53107 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53108 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53109 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53110 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53111 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53112 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53113 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53114 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53116 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53125 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53137 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53138 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53146 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53149 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53153 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53154 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53155 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53156 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53159 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53161 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53163 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53165 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53167 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53169 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53170 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53171 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53172 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53173 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53175 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53178 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53179 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53192 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53193 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53195 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53198 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53199 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53200 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53201 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53202 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53203 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53204 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53205 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53206 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53207 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53208 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53209 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53210 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53211 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53212 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53213 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53214 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53215 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53216 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53217 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53218 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53219 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53220 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53221 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53222 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53223 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53224 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53225 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53226 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53227 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53228 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53229 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53230 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53231 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53232 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53233 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53234 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53235 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53236 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53237 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53238 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53241 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53242 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53245 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53249 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53250 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53251 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53252 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53253 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53254 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53255 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53257 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53259 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53261 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53263 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53264 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53265 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53266 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53267 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53268 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53270 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53271 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53272 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53274 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53275 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53276 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53278 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53280 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53281 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53282 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53284 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53285 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53286 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53287 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53288 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53289 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53290 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53291 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53293 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53294 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53295 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53296 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53297 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53299 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53300 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53303 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53304 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53306 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53307 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53310 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53311 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53313 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53314 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53317 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53319 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53320 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53321 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53322 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53323 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53324 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53325 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53326 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53327 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53328 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53329 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53330 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53331 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53332 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53333 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53334 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53335 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53336 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53337 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53338 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53339 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53340 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53341 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53342 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53344 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53345 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53346 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53347 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53348 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53349 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53350 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53351 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53352 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53353 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53354 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53355 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53356 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53357 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53358 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53359 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53360 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53361 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53362 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53363 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53364 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53365 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53366 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53367 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53368 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53369 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53370 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53371 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53372 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53373 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53374 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53375 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53377 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53378 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53380 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53381 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53382 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53383 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53385 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53386 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53387 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53388 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53389 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53390 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53391 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53392 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53393 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53395 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53396 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53397 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53398 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53399 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53400 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53401 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53402 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53403 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53404 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53405 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53406 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53407 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53408 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53409 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53410 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53411 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53412 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53413 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53414 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53415 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53416 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53417 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53418 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53419 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53420 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53421 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53422 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53424 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53425 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53428 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53429 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53430 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53431 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53432 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53433 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53435 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53436 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53439 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53440 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53442 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53443 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53445 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53446 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53448 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53449 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53450 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53452 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53454 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53455 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53457 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53458 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53459 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53461 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53462 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53463 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53465 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53466 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53468 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53469 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53470 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53471 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53472 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53475 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53477 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53479 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53480 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53481 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53484 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53485 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53486 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53488 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53489 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53490 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53492 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53493 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53494 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53495 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53496 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53497 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53499 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53500 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53501 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53502 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53503 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53504 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53505 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53506 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53512 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53514 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53516 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53517 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53518 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53519 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53520 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53521 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53523 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53524 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53525 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53526 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53527 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53528 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53531 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53532 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53533 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53536 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53537 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53538 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53539 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53540 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53541 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53542 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53544 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53547 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53549 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53550 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53552 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53553 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53554 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53556 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53557 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53558 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53560 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53562 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53563 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53564 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53566 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53568 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53570 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53571 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53573 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53574 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53576 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53578 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53579 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53580 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53582 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53584 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53585 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53586 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53588 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53590 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53591 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53592 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53593 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53594 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53595 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53597 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53599 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53601 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53602 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53604 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53605 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53606 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53607 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53608 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53609 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53610 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53611 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53613 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53615 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53617 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53619 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53621 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53623 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53624 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53625 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53626 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53627 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53628 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53634 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53635 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53636 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53637 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53638 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53639 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53640 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53642 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53644 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53645 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53647 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53648 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53649 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53650 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53652 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53653 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53654 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53655 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53657 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53658 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53660 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53661 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53662 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53664 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53666 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53667 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53668 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53669 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53670 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53672 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53673 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53674 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53675 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53677 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53678 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53679 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53680 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53681 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53682 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53683 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53684 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53685 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53686 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53688 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53691 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53692 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53693 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53695 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53697 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53699 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53701 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53702 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53712 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53713 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53717 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53718 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53719 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53720 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53721 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53722 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53723 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53724 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53725 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53726 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53727 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53728 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53729 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53730 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53731 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53733 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53734 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53737 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53738 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53743 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53744 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53747 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53748 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53749 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53750 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53753 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53754 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53755 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53757 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53759 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53760 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53761 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53763 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53765 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53767 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53770 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53771 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53772 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53773 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53774 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53775 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53779 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53780 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53781 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53782 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53789 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53795 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53796 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53797 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53798 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53799 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53801 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53811 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53812 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53813 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53814 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53817 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53818 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53819 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53820 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53822 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53823 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53827 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53833 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53834 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53835 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53836 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53838 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53839 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53841 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53844 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53846 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53847 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53848 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53857 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
53861 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53862 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53864 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53875 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53876 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53877 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53878 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53882 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53885 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53887 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53890 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53891 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53892 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53893 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53896 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53898 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53899 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53900 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53901 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53902 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53907 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53908 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53909 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53911 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53912 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53913 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53915 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53917 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53918 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53919 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53921 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53922 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53925 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53933 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53940 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53948 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53951 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53952 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53965 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53967 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53969 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53970 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53972 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53974 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53975 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53977 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53978 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53979 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53983 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54002 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54003 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54005 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54007 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54008 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54009 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54011 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54012 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54015 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54016 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54018 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54019 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54021 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54024 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54025 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54027 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54029 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54031 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54032 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54034 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54035 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54038 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54040 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54042 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54044 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54047 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54049 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54050 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54051 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54053 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54054 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54055 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54057 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54059 { (char *)"Control_GetLabelText", _wrap_Control_GetLabelText, METH_VARARGS, NULL},
54060 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54062 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54064 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54065 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54069 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54073 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54074 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54076 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54080 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54082 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54084 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54085 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54086 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54087 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54091 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54092 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54093 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54094 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54096 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54097 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54098 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54099 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54100 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54102 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54103 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54104 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54105 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54106 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54107 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54108 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54110 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54112 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54113 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54114 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54115 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54116 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54117 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54120 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54121 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54122 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54124 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54125 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54126 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54135 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54140 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54141 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54142 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54143 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54144 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54145 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54151 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54152 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54156 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54157 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54159 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54160 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54162 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54164 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54165 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54167 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54168 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54169 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54174 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54175 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54176 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54177 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54178 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54179 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54180 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54183 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54184 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54187 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54189 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54190 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54191 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54192 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54193 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54194 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54196 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54200 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54201 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54202 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54203 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54204 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54205 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54206 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54208 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54209 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54210 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54211 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54212 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54213 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54214 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54215 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54216 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54217 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54218 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54219 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54220 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54221 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54222 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54225 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54226 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54227 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54228 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54229 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54230 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54231 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54232 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54234 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54235 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54236 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54237 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54238 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54239 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54240 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54241 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54242 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54243 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54244 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54245 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54246 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54247 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54248 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54249 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54250 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54251 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54252 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54253 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54254 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54255 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54256 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54257 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54258 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54259 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54260 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54261 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54262 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54263 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54264 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54265 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54266 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54267 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54268 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54269 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54270 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54271 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54272 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54273 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54274 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54275 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54276 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54277 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54278 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54279 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54280 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54281 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54282 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54283 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54284 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54285 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54286 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54287 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54288 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54289 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54290 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54291 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54292 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54293 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54294 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54295 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54296 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54297 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54298 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54299 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54300 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54301 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54302 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54303 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54304 { NULL, NULL, 0, NULL }
54305 };
54306
54307
54308 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54309
54310 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54311 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54312 }
54313 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54314 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54315 }
54316 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54317 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54318 }
54319 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54320 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54321 }
54322 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54323 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54324 }
54325 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54326 return (void *)((wxSizer *) ((wxGridSizer *) x));
54327 }
54328 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54329 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54330 }
54331 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54332 return (void *)((wxSizer *) ((wxPySizer *) x));
54333 }
54334 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54335 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54336 }
54337 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54338 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54339 }
54340 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54341 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54342 }
54343 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54344 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54345 }
54346 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54347 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54348 }
54349 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54350 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54351 }
54352 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54353 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54354 }
54355 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54356 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54357 }
54358 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54359 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54360 }
54361 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54362 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54363 }
54364 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54365 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54366 }
54367 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54368 return (void *)((wxEvent *) ((wxPyEvent *) x));
54369 }
54370 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54371 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54372 }
54373 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54374 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54375 }
54376 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54377 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54378 }
54379 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54380 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54381 }
54382 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54383 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54384 }
54385 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54386 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54387 }
54388 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54389 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54390 }
54391 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54392 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54393 }
54394 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54395 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54396 }
54397 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54398 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54399 }
54400 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54401 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54402 }
54403 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54404 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54405 }
54406 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54407 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54408 }
54409 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54410 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54411 }
54412 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54413 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54414 }
54415 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54416 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54417 }
54418 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54419 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54420 }
54421 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54422 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54423 }
54424 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54425 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54426 }
54427 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54428 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54429 }
54430 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54431 return (void *)((wxEvent *) ((wxShowEvent *) x));
54432 }
54433 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54434 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54435 }
54436 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54437 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54438 }
54439 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54440 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54441 }
54442 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54443 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54444 }
54445 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54446 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54447 }
54448 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54449 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54450 }
54451 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54452 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54453 }
54454 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54455 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54456 }
54457 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54458 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54459 }
54460 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54461 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54462 }
54463 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54464 return (void *)((wxControl *) ((wxControlWithItems *) x));
54465 }
54466 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54467 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54468 }
54469 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54470 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54471 }
54472 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54473 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54474 }
54475 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54476 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54477 }
54478 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54479 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54480 }
54481 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54482 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54483 }
54484 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54485 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54486 }
54487 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54488 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54489 }
54490 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54491 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54492 }
54493 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54494 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54495 }
54496 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54497 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54498 }
54499 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54500 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54501 }
54502 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54503 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54504 }
54505 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54506 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54507 }
54508 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54509 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54510 }
54511 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54512 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54513 }
54514 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54515 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54516 }
54517 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54518 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54519 }
54520 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54521 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54522 }
54523 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54524 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54525 }
54526 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54527 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54528 }
54529 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54530 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54531 }
54532 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54533 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54534 }
54535 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54536 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54537 }
54538 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54539 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54540 }
54541 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54542 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54543 }
54544 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54545 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54546 }
54547 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54548 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54549 }
54550 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54551 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54552 }
54553 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54554 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54555 }
54556 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54557 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54558 }
54559 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54560 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54561 }
54562 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54563 return (void *)((wxObject *) ((wxSizerItem *) x));
54564 }
54565 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54566 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54567 }
54568 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54569 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54570 }
54571 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54572 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54573 }
54574 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54575 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54576 }
54577 static void *_p_wxSizerTo_p_wxObject(void *x) {
54578 return (void *)((wxObject *) ((wxSizer *) x));
54579 }
54580 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54581 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54582 }
54583 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54584 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54585 }
54586 static void *_p_wxEventTo_p_wxObject(void *x) {
54587 return (void *)((wxObject *) ((wxEvent *) x));
54588 }
54589 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54590 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54591 }
54592 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54593 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54594 }
54595 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54596 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54597 }
54598 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54599 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54600 }
54601 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54602 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54603 }
54604 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54605 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54606 }
54607 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54608 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54609 }
54610 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54611 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54612 }
54613 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54614 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54615 }
54616 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54617 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54618 }
54619 static void *_p_wxControlTo_p_wxObject(void *x) {
54620 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54621 }
54622 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54623 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54624 }
54625 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54626 return (void *)((wxObject *) ((wxFSFile *) x));
54627 }
54628 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54629 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54630 }
54631 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54632 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54633 }
54634 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54635 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54636 }
54637 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54638 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54639 }
54640 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54641 return (void *)((wxObject *) ((wxMenuItem *) x));
54642 }
54643 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54644 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54645 }
54646 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54647 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54648 }
54649 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54650 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54651 }
54652 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54653 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54654 }
54655 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54656 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54657 }
54658 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54659 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54660 }
54661 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54662 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54663 }
54664 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54665 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54666 }
54667 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54668 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54669 }
54670 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54671 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54672 }
54673 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54674 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54675 }
54676 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54677 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54678 }
54679 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54680 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54681 }
54682 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54683 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54684 }
54685 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54686 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54687 }
54688 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54689 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54690 }
54691 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54692 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54693 }
54694 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54695 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54696 }
54697 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54698 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54699 }
54700 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54701 return (void *)((wxObject *) ((wxImageHandler *) x));
54702 }
54703 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54704 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54705 }
54706 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54707 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54708 }
54709 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54710 return (void *)((wxObject *) ((wxEvtHandler *) x));
54711 }
54712 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54713 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54714 }
54715 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54716 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54717 }
54718 static void *_p_wxImageTo_p_wxObject(void *x) {
54719 return (void *)((wxObject *) ((wxImage *) x));
54720 }
54721 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54722 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54723 }
54724 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54725 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54726 }
54727 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54728 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54729 }
54730 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54731 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54732 }
54733 static void *_p_wxWindowTo_p_wxObject(void *x) {
54734 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54735 }
54736 static void *_p_wxMenuTo_p_wxObject(void *x) {
54737 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54738 }
54739 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54740 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54741 }
54742 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54743 return (void *)((wxObject *) ((wxFileSystem *) x));
54744 }
54745 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54746 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54747 }
54748 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54749 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54750 }
54751 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54752 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54753 }
54754 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54755 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54756 }
54757 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54758 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54759 }
54760 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54761 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54762 }
54763 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54764 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54765 }
54766 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54767 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54768 }
54769 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54770 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54771 }
54772 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54773 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54774 }
54775 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54776 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54777 }
54778 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54779 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54780 }
54781 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54782 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54783 }
54784 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54785 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54786 }
54787 static void *_p_wxControlTo_p_wxWindow(void *x) {
54788 return (void *)((wxWindow *) ((wxControl *) x));
54789 }
54790 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54791 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54792 }
54793 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54794 return (void *)((wxWindow *) ((wxMenuBar *) x));
54795 }
54796 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54797 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54798 }
54799 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54800 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54801 }
54802 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54803 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54804 }
54805 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54806 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54807 }
54808 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54809 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54810 }
54811 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54812 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54813 }
54814 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54815 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54816 }
54817 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54818 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54819 }
54820 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54821 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54822 }
54823 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54824 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54825 }
54826 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54827 return (void *)((wxValidator *) ((wxPyValidator *) x));
54828 }
54829 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54830 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54831 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};
54832 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54833 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54834 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54835 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54836 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54837 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54838 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54839 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54840 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54841 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54842 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54843 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54844 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54845 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54846 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54847 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54848 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54849 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54850 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54851 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54852 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54853 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54854 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54855 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54856 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54857 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54858 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54859 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54860 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54861 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54862 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54863 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54864 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54865 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54866 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54867 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54868 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54869 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54870 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54871 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54872 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54873 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54874 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54875 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54876 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54877 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54878 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54879 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54880 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54881 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54882 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54883 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54884 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54885 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54886 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54887 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54888 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54889 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54890 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54891 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54892 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54893 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54894 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54895 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54896 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54897 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54898 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54899 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54900 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54901 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54902 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54903 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54904 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54905 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54906 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54907 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54908 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54909 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54910 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54911 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54912 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54913 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54914 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54915 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54916 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54917 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54918 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54919 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54920 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54921 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54922 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54923 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54924 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54925 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54926 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54927 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54928 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54929 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54930 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54931 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54932 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54933 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54934 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54935 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54936 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54937 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54938 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54939 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54940 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54941 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54942 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54943 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54944 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54945 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54946 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54947 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54948 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54949 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54950 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54951 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54952 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54953 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54954 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54955 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54956 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54957 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54958 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54959 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54960
54961 static swig_type_info *swig_type_initial[] = {
54962 &_swigt__p_buffer,
54963 &_swigt__p_char,
54964 &_swigt__p_form_ops_t,
54965 &_swigt__p_int,
54966 &_swigt__p_long,
54967 &_swigt__p_unsigned_char,
54968 &_swigt__p_unsigned_int,
54969 &_swigt__p_unsigned_long,
54970 &_swigt__p_wxANIHandler,
54971 &_swigt__p_wxAcceleratorEntry,
54972 &_swigt__p_wxAcceleratorTable,
54973 &_swigt__p_wxActivateEvent,
54974 &_swigt__p_wxAppTraits,
54975 &_swigt__p_wxArrayString,
54976 &_swigt__p_wxBMPHandler,
54977 &_swigt__p_wxBitmap,
54978 &_swigt__p_wxBoxSizer,
54979 &_swigt__p_wxButton,
54980 &_swigt__p_wxCURHandler,
54981 &_swigt__p_wxCaret,
54982 &_swigt__p_wxChildFocusEvent,
54983 &_swigt__p_wxClipboardTextEvent,
54984 &_swigt__p_wxCloseEvent,
54985 &_swigt__p_wxColour,
54986 &_swigt__p_wxCommandEvent,
54987 &_swigt__p_wxContextMenuEvent,
54988 &_swigt__p_wxControl,
54989 &_swigt__p_wxControlWithItems,
54990 &_swigt__p_wxCursor,
54991 &_swigt__p_wxDC,
54992 &_swigt__p_wxDateEvent,
54993 &_swigt__p_wxDateTime,
54994 &_swigt__p_wxDisplayChangedEvent,
54995 &_swigt__p_wxDropFilesEvent,
54996 &_swigt__p_wxDuplexMode,
54997 &_swigt__p_wxEraseEvent,
54998 &_swigt__p_wxEvent,
54999 &_swigt__p_wxEventLoop,
55000 &_swigt__p_wxEventLoopActivator,
55001 &_swigt__p_wxEvtHandler,
55002 &_swigt__p_wxFSFile,
55003 &_swigt__p_wxFileSystem,
55004 &_swigt__p_wxFileSystemHandler,
55005 &_swigt__p_wxFlexGridSizer,
55006 &_swigt__p_wxFocusEvent,
55007 &_swigt__p_wxFont,
55008 &_swigt__p_wxFrame,
55009 &_swigt__p_wxGBPosition,
55010 &_swigt__p_wxGBSizerItem,
55011 &_swigt__p_wxGBSpan,
55012 &_swigt__p_wxGIFHandler,
55013 &_swigt__p_wxGridBagSizer,
55014 &_swigt__p_wxGridSizer,
55015 &_swigt__p_wxHelpEvent__Origin,
55016 &_swigt__p_wxICOHandler,
55017 &_swigt__p_wxIconizeEvent,
55018 &_swigt__p_wxIdleEvent,
55019 &_swigt__p_wxImage,
55020 &_swigt__p_wxImageHandler,
55021 &_swigt__p_wxImageHistogram,
55022 &_swigt__p_wxImage_HSVValue,
55023 &_swigt__p_wxImage_RGBValue,
55024 &_swigt__p_wxIndividualLayoutConstraint,
55025 &_swigt__p_wxInitDialogEvent,
55026 &_swigt__p_wxInputStream,
55027 &_swigt__p_wxInternetFSHandler,
55028 &_swigt__p_wxItemContainer,
55029 &_swigt__p_wxJPEGHandler,
55030 &_swigt__p_wxKeyEvent,
55031 &_swigt__p_wxLayoutConstraints,
55032 &_swigt__p_wxMaximizeEvent,
55033 &_swigt__p_wxMemoryFSHandler,
55034 &_swigt__p_wxMenu,
55035 &_swigt__p_wxMenuBar,
55036 &_swigt__p_wxMenuBarBase,
55037 &_swigt__p_wxMenuEvent,
55038 &_swigt__p_wxMenuItem,
55039 &_swigt__p_wxMouseCaptureChangedEvent,
55040 &_swigt__p_wxMouseEvent,
55041 &_swigt__p_wxMoveEvent,
55042 &_swigt__p_wxNavigationKeyEvent,
55043 &_swigt__p_wxNcPaintEvent,
55044 &_swigt__p_wxNotifyEvent,
55045 &_swigt__p_wxObject,
55046 &_swigt__p_wxOutputStream,
55047 &_swigt__p_wxPCXHandler,
55048 &_swigt__p_wxPNGHandler,
55049 &_swigt__p_wxPNMHandler,
55050 &_swigt__p_wxPaintEvent,
55051 &_swigt__p_wxPaletteChangedEvent,
55052 &_swigt__p_wxPaperSize,
55053 &_swigt__p_wxPoint,
55054 &_swigt__p_wxPoint2D,
55055 &_swigt__p_wxPropagateOnce,
55056 &_swigt__p_wxPropagationDisabler,
55057 &_swigt__p_wxPyApp,
55058 &_swigt__p_wxPyCommandEvent,
55059 &_swigt__p_wxPyDropTarget,
55060 &_swigt__p_wxPyEvent,
55061 &_swigt__p_wxPyFileSystemHandler,
55062 &_swigt__p_wxPyImageHandler,
55063 &_swigt__p_wxPyInputStream,
55064 &_swigt__p_wxPySizer,
55065 &_swigt__p_wxPyValidator,
55066 &_swigt__p_wxQuantize,
55067 &_swigt__p_wxQueryNewPaletteEvent,
55068 &_swigt__p_wxRealPoint,
55069 &_swigt__p_wxRect,
55070 &_swigt__p_wxRegion,
55071 &_swigt__p_wxScrollEvent,
55072 &_swigt__p_wxScrollWinEvent,
55073 &_swigt__p_wxSetCursorEvent,
55074 &_swigt__p_wxShowEvent,
55075 &_swigt__p_wxSize,
55076 &_swigt__p_wxSizeEvent,
55077 &_swigt__p_wxSizer,
55078 &_swigt__p_wxSizerItem,
55079 &_swigt__p_wxStaticBox,
55080 &_swigt__p_wxStaticBoxSizer,
55081 &_swigt__p_wxStdDialogButtonSizer,
55082 &_swigt__p_wxSysColourChangedEvent,
55083 &_swigt__p_wxTIFFHandler,
55084 &_swigt__p_wxToolTip,
55085 &_swigt__p_wxUpdateUIEvent,
55086 &_swigt__p_wxValidator,
55087 &_swigt__p_wxVisualAttributes,
55088 &_swigt__p_wxWindow,
55089 &_swigt__p_wxWindowCreateEvent,
55090 &_swigt__p_wxWindowDestroyEvent,
55091 &_swigt__p_wxXPMHandler,
55092 &_swigt__p_wxZipFSHandler,
55093 };
55094
55095 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55096 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55097 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55098 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55099 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55100 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55101 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55102 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55103 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55104 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55105 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55106 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55107 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55108 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55109 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}};
55110 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55111 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}};
55112 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55113 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}};
55114 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55115 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55116 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55117 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55118 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55119 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}};
55120 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55121 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}};
55122 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55123 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55124 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55125 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55126 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55127 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55128 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55129 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55130 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55131 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
55132 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55133 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55134 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}};
55135 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55136 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55137 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}};
55138 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}};
55139 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55140 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55141 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55142 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55143 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55144 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55145 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55146 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55147 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}};
55148 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55149 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}};
55150 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55151 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55152 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55153 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}};
55154 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55155 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55156 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55157 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55158 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55159 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55160 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55161 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}};
55162 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55163 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55164 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55165 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55166 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55167 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55168 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55169 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55170 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55171 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55172 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55173 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55174 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55175 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55176 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55177 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55178 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
55179 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55180 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55181 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55182 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55183 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55184 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55185 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55186 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55187 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55188 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55189 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55190 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55191 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55192 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55193 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55194 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55195 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55196 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55197 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55198 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55199 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55200 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55201 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55202 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55203 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55204 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55205 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55206 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55207 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55208 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55209 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55210 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}};
55211 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}};
55212 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55213 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55214 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55215 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55216 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55217 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55218 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55219 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}};
55220 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55221 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}};
55222 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55223 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55224 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55225 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55226
55227 static swig_cast_info *swig_cast_initial[] = {
55228 _swigc__p_buffer,
55229 _swigc__p_char,
55230 _swigc__p_form_ops_t,
55231 _swigc__p_int,
55232 _swigc__p_long,
55233 _swigc__p_unsigned_char,
55234 _swigc__p_unsigned_int,
55235 _swigc__p_unsigned_long,
55236 _swigc__p_wxANIHandler,
55237 _swigc__p_wxAcceleratorEntry,
55238 _swigc__p_wxAcceleratorTable,
55239 _swigc__p_wxActivateEvent,
55240 _swigc__p_wxAppTraits,
55241 _swigc__p_wxArrayString,
55242 _swigc__p_wxBMPHandler,
55243 _swigc__p_wxBitmap,
55244 _swigc__p_wxBoxSizer,
55245 _swigc__p_wxButton,
55246 _swigc__p_wxCURHandler,
55247 _swigc__p_wxCaret,
55248 _swigc__p_wxChildFocusEvent,
55249 _swigc__p_wxClipboardTextEvent,
55250 _swigc__p_wxCloseEvent,
55251 _swigc__p_wxColour,
55252 _swigc__p_wxCommandEvent,
55253 _swigc__p_wxContextMenuEvent,
55254 _swigc__p_wxControl,
55255 _swigc__p_wxControlWithItems,
55256 _swigc__p_wxCursor,
55257 _swigc__p_wxDC,
55258 _swigc__p_wxDateEvent,
55259 _swigc__p_wxDateTime,
55260 _swigc__p_wxDisplayChangedEvent,
55261 _swigc__p_wxDropFilesEvent,
55262 _swigc__p_wxDuplexMode,
55263 _swigc__p_wxEraseEvent,
55264 _swigc__p_wxEvent,
55265 _swigc__p_wxEventLoop,
55266 _swigc__p_wxEventLoopActivator,
55267 _swigc__p_wxEvtHandler,
55268 _swigc__p_wxFSFile,
55269 _swigc__p_wxFileSystem,
55270 _swigc__p_wxFileSystemHandler,
55271 _swigc__p_wxFlexGridSizer,
55272 _swigc__p_wxFocusEvent,
55273 _swigc__p_wxFont,
55274 _swigc__p_wxFrame,
55275 _swigc__p_wxGBPosition,
55276 _swigc__p_wxGBSizerItem,
55277 _swigc__p_wxGBSpan,
55278 _swigc__p_wxGIFHandler,
55279 _swigc__p_wxGridBagSizer,
55280 _swigc__p_wxGridSizer,
55281 _swigc__p_wxHelpEvent__Origin,
55282 _swigc__p_wxICOHandler,
55283 _swigc__p_wxIconizeEvent,
55284 _swigc__p_wxIdleEvent,
55285 _swigc__p_wxImage,
55286 _swigc__p_wxImageHandler,
55287 _swigc__p_wxImageHistogram,
55288 _swigc__p_wxImage_HSVValue,
55289 _swigc__p_wxImage_RGBValue,
55290 _swigc__p_wxIndividualLayoutConstraint,
55291 _swigc__p_wxInitDialogEvent,
55292 _swigc__p_wxInputStream,
55293 _swigc__p_wxInternetFSHandler,
55294 _swigc__p_wxItemContainer,
55295 _swigc__p_wxJPEGHandler,
55296 _swigc__p_wxKeyEvent,
55297 _swigc__p_wxLayoutConstraints,
55298 _swigc__p_wxMaximizeEvent,
55299 _swigc__p_wxMemoryFSHandler,
55300 _swigc__p_wxMenu,
55301 _swigc__p_wxMenuBar,
55302 _swigc__p_wxMenuBarBase,
55303 _swigc__p_wxMenuEvent,
55304 _swigc__p_wxMenuItem,
55305 _swigc__p_wxMouseCaptureChangedEvent,
55306 _swigc__p_wxMouseEvent,
55307 _swigc__p_wxMoveEvent,
55308 _swigc__p_wxNavigationKeyEvent,
55309 _swigc__p_wxNcPaintEvent,
55310 _swigc__p_wxNotifyEvent,
55311 _swigc__p_wxObject,
55312 _swigc__p_wxOutputStream,
55313 _swigc__p_wxPCXHandler,
55314 _swigc__p_wxPNGHandler,
55315 _swigc__p_wxPNMHandler,
55316 _swigc__p_wxPaintEvent,
55317 _swigc__p_wxPaletteChangedEvent,
55318 _swigc__p_wxPaperSize,
55319 _swigc__p_wxPoint,
55320 _swigc__p_wxPoint2D,
55321 _swigc__p_wxPropagateOnce,
55322 _swigc__p_wxPropagationDisabler,
55323 _swigc__p_wxPyApp,
55324 _swigc__p_wxPyCommandEvent,
55325 _swigc__p_wxPyDropTarget,
55326 _swigc__p_wxPyEvent,
55327 _swigc__p_wxPyFileSystemHandler,
55328 _swigc__p_wxPyImageHandler,
55329 _swigc__p_wxPyInputStream,
55330 _swigc__p_wxPySizer,
55331 _swigc__p_wxPyValidator,
55332 _swigc__p_wxQuantize,
55333 _swigc__p_wxQueryNewPaletteEvent,
55334 _swigc__p_wxRealPoint,
55335 _swigc__p_wxRect,
55336 _swigc__p_wxRegion,
55337 _swigc__p_wxScrollEvent,
55338 _swigc__p_wxScrollWinEvent,
55339 _swigc__p_wxSetCursorEvent,
55340 _swigc__p_wxShowEvent,
55341 _swigc__p_wxSize,
55342 _swigc__p_wxSizeEvent,
55343 _swigc__p_wxSizer,
55344 _swigc__p_wxSizerItem,
55345 _swigc__p_wxStaticBox,
55346 _swigc__p_wxStaticBoxSizer,
55347 _swigc__p_wxStdDialogButtonSizer,
55348 _swigc__p_wxSysColourChangedEvent,
55349 _swigc__p_wxTIFFHandler,
55350 _swigc__p_wxToolTip,
55351 _swigc__p_wxUpdateUIEvent,
55352 _swigc__p_wxValidator,
55353 _swigc__p_wxVisualAttributes,
55354 _swigc__p_wxWindow,
55355 _swigc__p_wxWindowCreateEvent,
55356 _swigc__p_wxWindowDestroyEvent,
55357 _swigc__p_wxXPMHandler,
55358 _swigc__p_wxZipFSHandler,
55359 };
55360
55361
55362 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55363
55364 static swig_const_info swig_const_table[] = {
55365 {0, 0, 0, 0.0, 0, 0}};
55366
55367 #ifdef __cplusplus
55368 }
55369 #endif
55370 /* -----------------------------------------------------------------------------
55371 * Type initialization:
55372 * This problem is tough by the requirement that no dynamic
55373 * memory is used. Also, since swig_type_info structures store pointers to
55374 * swig_cast_info structures and swig_cast_info structures store pointers back
55375 * to swig_type_info structures, we need some lookup code at initialization.
55376 * The idea is that swig generates all the structures that are needed.
55377 * The runtime then collects these partially filled structures.
55378 * The SWIG_InitializeModule function takes these initial arrays out of
55379 * swig_module, and does all the lookup, filling in the swig_module.types
55380 * array with the correct data and linking the correct swig_cast_info
55381 * structures together.
55382 *
55383 * The generated swig_type_info structures are assigned staticly to an initial
55384 * array. We just loop though that array, and handle each type individually.
55385 * First we lookup if this type has been already loaded, and if so, use the
55386 * loaded structure instead of the generated one. Then we have to fill in the
55387 * cast linked list. The cast data is initially stored in something like a
55388 * two-dimensional array. Each row corresponds to a type (there are the same
55389 * number of rows as there are in the swig_type_initial array). Each entry in
55390 * a column is one of the swig_cast_info structures for that type.
55391 * The cast_initial array is actually an array of arrays, because each row has
55392 * a variable number of columns. So to actually build the cast linked list,
55393 * we find the array of casts associated with the type, and loop through it
55394 * adding the casts to the list. The one last trick we need to do is making
55395 * sure the type pointer in the swig_cast_info struct is correct.
55396 *
55397 * First off, we lookup the cast->type name to see if it is already loaded.
55398 * There are three cases to handle:
55399 * 1) If the cast->type has already been loaded AND the type we are adding
55400 * casting info to has not been loaded (it is in this module), THEN we
55401 * replace the cast->type pointer with the type pointer that has already
55402 * been loaded.
55403 * 2) If BOTH types (the one we are adding casting info to, and the
55404 * cast->type) are loaded, THEN the cast info has already been loaded by
55405 * the previous module so we just ignore it.
55406 * 3) Finally, if cast->type has not already been loaded, then we add that
55407 * swig_cast_info to the linked list (because the cast->type) pointer will
55408 * be correct.
55409 * ----------------------------------------------------------------------------- */
55410
55411 #ifdef __cplusplus
55412 extern "C" {
55413 #if 0
55414 } /* c-mode */
55415 #endif
55416 #endif
55417
55418 #if 0
55419 #define SWIGRUNTIME_DEBUG
55420 #endif
55421
55422 SWIGRUNTIME void
55423 SWIG_InitializeModule(void *clientdata) {
55424 size_t i;
55425 swig_module_info *module_head;
55426 static int init_run = 0;
55427
55428 clientdata = clientdata;
55429
55430 if (init_run) return;
55431 init_run = 1;
55432
55433 /* Initialize the swig_module */
55434 swig_module.type_initial = swig_type_initial;
55435 swig_module.cast_initial = swig_cast_initial;
55436
55437 /* Try and load any already created modules */
55438 module_head = SWIG_GetModule(clientdata);
55439 if (module_head) {
55440 swig_module.next = module_head->next;
55441 module_head->next = &swig_module;
55442 } else {
55443 /* This is the first module loaded */
55444 swig_module.next = &swig_module;
55445 SWIG_SetModule(clientdata, &swig_module);
55446 }
55447
55448 /* Now work on filling in swig_module.types */
55449 #ifdef SWIGRUNTIME_DEBUG
55450 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55451 #endif
55452 for (i = 0; i < swig_module.size; ++i) {
55453 swig_type_info *type = 0;
55454 swig_type_info *ret;
55455 swig_cast_info *cast;
55456
55457 #ifdef SWIGRUNTIME_DEBUG
55458 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55459 #endif
55460
55461 /* if there is another module already loaded */
55462 if (swig_module.next != &swig_module) {
55463 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55464 }
55465 if (type) {
55466 /* Overwrite clientdata field */
55467 #ifdef SWIGRUNTIME_DEBUG
55468 printf("SWIG_InitializeModule: found type %s\n", type->name);
55469 #endif
55470 if (swig_module.type_initial[i]->clientdata) {
55471 type->clientdata = swig_module.type_initial[i]->clientdata;
55472 #ifdef SWIGRUNTIME_DEBUG
55473 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55474 #endif
55475 }
55476 } else {
55477 type = swig_module.type_initial[i];
55478 }
55479
55480 /* Insert casting types */
55481 cast = swig_module.cast_initial[i];
55482 while (cast->type) {
55483 /* Don't need to add information already in the list */
55484 ret = 0;
55485 #ifdef SWIGRUNTIME_DEBUG
55486 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55487 #endif
55488 if (swig_module.next != &swig_module) {
55489 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55490 #ifdef SWIGRUNTIME_DEBUG
55491 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55492 #endif
55493 }
55494 if (ret) {
55495 if (type == swig_module.type_initial[i]) {
55496 #ifdef SWIGRUNTIME_DEBUG
55497 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55498 #endif
55499 cast->type = ret;
55500 ret = 0;
55501 } else {
55502 /* Check for casting already in the list */
55503 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55504 #ifdef SWIGRUNTIME_DEBUG
55505 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55506 #endif
55507 if (!ocast) ret = 0;
55508 }
55509 }
55510
55511 if (!ret) {
55512 #ifdef SWIGRUNTIME_DEBUG
55513 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55514 #endif
55515 if (type->cast) {
55516 type->cast->prev = cast;
55517 cast->next = type->cast;
55518 }
55519 type->cast = cast;
55520 }
55521 cast++;
55522 }
55523 /* Set entry in modules->types array equal to the type */
55524 swig_module.types[i] = type;
55525 }
55526 swig_module.types[i] = 0;
55527
55528 #ifdef SWIGRUNTIME_DEBUG
55529 printf("**** SWIG_InitializeModule: Cast List ******\n");
55530 for (i = 0; i < swig_module.size; ++i) {
55531 int j = 0;
55532 swig_cast_info *cast = swig_module.cast_initial[i];
55533 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55534 while (cast->type) {
55535 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55536 cast++;
55537 ++j;
55538 }
55539 printf("---- Total casts: %d\n",j);
55540 }
55541 printf("**** SWIG_InitializeModule: Cast List ******\n");
55542 #endif
55543 }
55544
55545 /* This function will propagate the clientdata field of type to
55546 * any new swig_type_info structures that have been added into the list
55547 * of equivalent types. It is like calling
55548 * SWIG_TypeClientData(type, clientdata) a second time.
55549 */
55550 SWIGRUNTIME void
55551 SWIG_PropagateClientData(void) {
55552 size_t i;
55553 swig_cast_info *equiv;
55554 static int init_run = 0;
55555
55556 if (init_run) return;
55557 init_run = 1;
55558
55559 for (i = 0; i < swig_module.size; i++) {
55560 if (swig_module.types[i]->clientdata) {
55561 equiv = swig_module.types[i]->cast;
55562 while (equiv) {
55563 if (!equiv->converter) {
55564 if (equiv->type && !equiv->type->clientdata)
55565 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55566 }
55567 equiv = equiv->next;
55568 }
55569 }
55570 }
55571 }
55572
55573 #ifdef __cplusplus
55574 #if 0
55575 {
55576 /* c-mode */
55577 #endif
55578 }
55579 #endif
55580
55581
55582
55583 #ifdef __cplusplus
55584 extern "C" {
55585 #endif
55586
55587 /* Python-specific SWIG API */
55588 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55589 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55590 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55591
55592 /* -----------------------------------------------------------------------------
55593 * global variable support code.
55594 * ----------------------------------------------------------------------------- */
55595
55596 typedef struct swig_globalvar {
55597 char *name; /* Name of global variable */
55598 PyObject *(*get_attr)(void); /* Return the current value */
55599 int (*set_attr)(PyObject *); /* Set the value */
55600 struct swig_globalvar *next;
55601 } swig_globalvar;
55602
55603 typedef struct swig_varlinkobject {
55604 PyObject_HEAD
55605 swig_globalvar *vars;
55606 } swig_varlinkobject;
55607
55608 SWIGINTERN PyObject *
55609 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55610 return PyString_FromString("<Swig global variables>");
55611 }
55612
55613 SWIGINTERN PyObject *
55614 swig_varlink_str(swig_varlinkobject *v) {
55615 PyObject *str = PyString_FromString("(");
55616 swig_globalvar *var;
55617 for (var = v->vars; var; var=var->next) {
55618 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55619 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55620 }
55621 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55622 return str;
55623 }
55624
55625 SWIGINTERN int
55626 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55627 PyObject *str = swig_varlink_str(v);
55628 fprintf(fp,"Swig global variables ");
55629 fprintf(fp,"%s\n", PyString_AsString(str));
55630 Py_DECREF(str);
55631 return 0;
55632 }
55633
55634 SWIGINTERN void
55635 swig_varlink_dealloc(swig_varlinkobject *v) {
55636 swig_globalvar *var = v->vars;
55637 while (var) {
55638 swig_globalvar *n = var->next;
55639 free(var->name);
55640 free(var);
55641 var = n;
55642 }
55643 }
55644
55645 SWIGINTERN PyObject *
55646 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55647 PyObject *res = NULL;
55648 swig_globalvar *var = v->vars;
55649 while (var) {
55650 if (strcmp(var->name,n) == 0) {
55651 res = (*var->get_attr)();
55652 break;
55653 }
55654 var = var->next;
55655 }
55656 if (res == NULL && !PyErr_Occurred()) {
55657 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55658 }
55659 return res;
55660 }
55661
55662 SWIGINTERN int
55663 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55664 int res = 1;
55665 swig_globalvar *var = v->vars;
55666 while (var) {
55667 if (strcmp(var->name,n) == 0) {
55668 res = (*var->set_attr)(p);
55669 break;
55670 }
55671 var = var->next;
55672 }
55673 if (res == 1 && !PyErr_Occurred()) {
55674 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55675 }
55676 return res;
55677 }
55678
55679 SWIGINTERN PyTypeObject*
55680 swig_varlink_type(void) {
55681 static char varlink__doc__[] = "Swig var link object";
55682 static PyTypeObject varlink_type;
55683 static int type_init = 0;
55684 if (!type_init) {
55685 const PyTypeObject tmp
55686 = {
55687 PyObject_HEAD_INIT(NULL)
55688 0, /* Number of items in variable part (ob_size) */
55689 (char *)"swigvarlink", /* Type name (tp_name) */
55690 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55691 0, /* Itemsize (tp_itemsize) */
55692 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55693 (printfunc) swig_varlink_print, /* Print (tp_print) */
55694 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55695 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55696 0, /* tp_compare */
55697 (reprfunc) swig_varlink_repr, /* tp_repr */
55698 0, /* tp_as_number */
55699 0, /* tp_as_sequence */
55700 0, /* tp_as_mapping */
55701 0, /* tp_hash */
55702 0, /* tp_call */
55703 (reprfunc)swig_varlink_str, /* tp_str */
55704 0, /* tp_getattro */
55705 0, /* tp_setattro */
55706 0, /* tp_as_buffer */
55707 0, /* tp_flags */
55708 varlink__doc__, /* tp_doc */
55709 0, /* tp_traverse */
55710 0, /* tp_clear */
55711 0, /* tp_richcompare */
55712 0, /* tp_weaklistoffset */
55713 #if PY_VERSION_HEX >= 0x02020000
55714 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55715 #endif
55716 #if PY_VERSION_HEX >= 0x02030000
55717 0, /* tp_del */
55718 #endif
55719 #ifdef COUNT_ALLOCS
55720 0,0,0,0 /* tp_alloc -> tp_next */
55721 #endif
55722 };
55723 varlink_type = tmp;
55724 varlink_type.ob_type = &PyType_Type;
55725 type_init = 1;
55726 }
55727 return &varlink_type;
55728 }
55729
55730 /* Create a variable linking object for use later */
55731 SWIGINTERN PyObject *
55732 SWIG_Python_newvarlink(void) {
55733 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55734 if (result) {
55735 result->vars = 0;
55736 }
55737 return ((PyObject*) result);
55738 }
55739
55740 SWIGINTERN void
55741 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55742 swig_varlinkobject *v = (swig_varlinkobject *) p;
55743 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55744 if (gv) {
55745 size_t size = strlen(name)+1;
55746 gv->name = (char *)malloc(size);
55747 if (gv->name) {
55748 strncpy(gv->name,name,size);
55749 gv->get_attr = get_attr;
55750 gv->set_attr = set_attr;
55751 gv->next = v->vars;
55752 }
55753 }
55754 v->vars = gv;
55755 }
55756
55757 SWIGINTERN PyObject *
55758 SWIG_globals() {
55759 static PyObject *_SWIG_globals = 0;
55760 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55761 return _SWIG_globals;
55762 }
55763
55764 /* -----------------------------------------------------------------------------
55765 * constants/methods manipulation
55766 * ----------------------------------------------------------------------------- */
55767
55768 /* Install Constants */
55769 SWIGINTERN void
55770 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55771 PyObject *obj = 0;
55772 size_t i;
55773 for (i = 0; constants[i].type; ++i) {
55774 switch(constants[i].type) {
55775 case SWIG_PY_POINTER:
55776 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55777 break;
55778 case SWIG_PY_BINARY:
55779 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55780 break;
55781 default:
55782 obj = 0;
55783 break;
55784 }
55785 if (obj) {
55786 PyDict_SetItemString(d, constants[i].name, obj);
55787 Py_DECREF(obj);
55788 }
55789 }
55790 }
55791
55792 /* -----------------------------------------------------------------------------*/
55793 /* Fix SwigMethods to carry the callback ptrs when needed */
55794 /* -----------------------------------------------------------------------------*/
55795
55796 SWIGINTERN void
55797 SWIG_Python_FixMethods(PyMethodDef *methods,
55798 swig_const_info *const_table,
55799 swig_type_info **types,
55800 swig_type_info **types_initial) {
55801 size_t i;
55802 for (i = 0; methods[i].ml_name; ++i) {
55803 const char *c = methods[i].ml_doc;
55804 if (c && (c = strstr(c, "swig_ptr: "))) {
55805 int j;
55806 swig_const_info *ci = 0;
55807 const char *name = c + 10;
55808 for (j = 0; const_table[j].type; ++j) {
55809 if (strncmp(const_table[j].name, name,
55810 strlen(const_table[j].name)) == 0) {
55811 ci = &(const_table[j]);
55812 break;
55813 }
55814 }
55815 if (ci) {
55816 size_t shift = (ci->ptype) - types;
55817 swig_type_info *ty = types_initial[shift];
55818 size_t ldoc = (c - methods[i].ml_doc);
55819 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55820 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55821 if (ndoc) {
55822 char *buff = ndoc;
55823 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55824 if (ptr) {
55825 strncpy(buff, methods[i].ml_doc, ldoc);
55826 buff += ldoc;
55827 strncpy(buff, "swig_ptr: ", 10);
55828 buff += 10;
55829 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55830 methods[i].ml_doc = ndoc;
55831 }
55832 }
55833 }
55834 }
55835 }
55836 }
55837
55838 #ifdef __cplusplus
55839 }
55840 #endif
55841
55842 /* -----------------------------------------------------------------------------*
55843 * Partial Init method
55844 * -----------------------------------------------------------------------------*/
55845
55846 #ifdef __cplusplus
55847 extern "C"
55848 #endif
55849 SWIGEXPORT void SWIG_init(void) {
55850 PyObject *m, *d;
55851
55852 /* Fix SwigMethods to carry the callback ptrs when needed */
55853 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55854
55855 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55856 d = PyModule_GetDict(m);
55857
55858 SWIG_InitializeModule(0);
55859 SWIG_InstallConstants(d,swig_const_table);
55860
55861
55862
55863 #ifndef wxPyUSE_EXPORT
55864 // Make our API structure a CObject so other modules can import it
55865 // from this module.
55866 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55867 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55868 Py_XDECREF(cobj);
55869 #endif
55870
55871 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55872 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55873 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55874 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55875 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55876 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55877 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55878 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55879 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55880 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55881 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55882 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55883 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55884 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55885 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55886 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55887 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55888 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55889 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55890 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55891 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55892 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55893 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55894 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55895 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55896 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55897 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55898 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55899 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55900 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55901 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55902 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55903 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55904 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55905 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55906 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55907 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55908 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55909 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55910 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55911 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55912 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55913 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55914 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55915 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55916 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55917 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55918 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55919 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55920 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55921 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55922 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55923 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55924 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55925 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55926 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55927 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55928 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55929 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55930 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55931 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55932 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55933 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55934 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55935 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55936 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55937 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55938 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55939 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55940 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55941 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55942 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55943 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55944 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55945 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55946 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55947 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55948 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55949 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55950 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55951 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55952 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55953 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55954 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55955 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55956 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55957 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55958 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55959 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55960 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55961 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55962 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55963 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55964 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55965 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55966 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55967 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55968 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55969 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55970 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55971 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55972 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55973 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55974 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55975 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55976 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55977 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55978 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55979 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55980 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55981 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55982 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55983 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55984 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55985 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55986 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55987 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55988 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55989 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55990 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55991 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
55992 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
55993 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55994 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55995 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55996 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55997 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55998 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55999 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56000 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56001 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56002 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56003 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56004 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56005 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56006 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56007 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56008 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56009 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56010 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56011 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56012 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56013 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56014 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56015 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56016 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56017 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56018 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56019 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56020 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56021 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56022 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56023 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56024 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56025 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56026 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56027 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56028 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56029 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56030 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56031 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56032 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56033 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56034 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56035 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56036 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56037 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56038 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56039 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56040 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56041 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56042 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56043 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56044 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56045 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56046 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56047 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56048 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56049 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56050 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56051 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56052 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56053 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56054 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56055 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56056 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56057 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56058 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56059 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56060 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56061 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56062 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56063 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56064 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56065 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56066 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56067 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56068 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56069 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56070 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56071 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56072 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56073 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56074 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56075 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56076 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56077 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56078 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56079 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56080 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56081 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56082 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56083 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56084 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56085 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56086 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56087 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56088 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56089 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56090 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56091 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56092 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56093 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56094 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56095 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56096 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56097 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56098 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56099 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56100 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56101 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56102 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56103 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56104 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56105 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56106 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56107 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56108 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56109 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56110 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56111 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56112 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56113 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56114 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56115 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56116 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56117 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56118 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56119 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56120 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56121 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56122 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56123 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56124 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56125 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56126 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56127 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56128 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56129 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56130 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56131 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56132 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56133 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56134 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56135 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56136 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56137 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56138 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56139 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56140 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56141 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56142 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56143 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56144 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56145 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56146 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56147 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56148 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56149 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56150 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56151 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56152 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56153 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56154 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56155 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56156 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56157 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56158 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56159 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56160 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56161 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56162 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56163 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56164 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56165 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56166 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56167 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56168 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56169 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56170 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56171 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56172 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56173 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56174 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56175 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56176 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56177 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56178 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56179 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56180 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56181 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56182 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56183 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56184 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56185 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56186 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56187 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56188 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56189 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56190 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56191 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56192 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56193 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56194 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56195 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56196 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56197 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56198 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56199 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56200 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56201 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56202 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56203 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56204 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56205 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56206 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56207 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56208 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56209 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56210 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56211 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56212 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56213 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56214 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56215 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56216 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56217 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56218 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56219 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56220 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56221 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56222 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56223 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56224 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56225 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56226 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56227 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56228 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56229 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56230 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56231 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56232 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56233 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56234 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56235 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56236 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56237 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56238 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56239 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56240 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56241 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56242 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56243 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56244 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56245 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56246 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56247 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56248 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56249 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56250 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56251 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56252 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56253 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56254 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56255 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56256 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56257 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56258 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56259 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56260 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56261 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56262 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56263 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56264 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56265 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56266 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56267 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56268 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56269 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56270 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56271 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56272 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56273 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56274 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56275 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56276 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56277 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56278 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56279 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56280 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56281 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56282 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56283 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56284 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56285 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56286 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56287 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56288 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56289 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56290 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56291 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56292 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56293 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56294 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56295 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56296 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56297 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56298 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56299 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56300 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56301 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56302 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56303 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56304 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56305 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56306 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56307 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56308 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56309 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56310 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56311 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56312 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56313 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56314 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56315 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56316 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56317 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56318 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56319 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56320 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56321 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56322 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56323 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56324 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56325 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56326 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56327 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56328 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56329 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56330 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56331 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56332 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56333 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56334 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56335 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56336 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56337 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56338 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56339 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56340 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56341 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56342 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56343 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56344 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56345 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56346 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56347 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56348 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56349 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56350 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56351 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56352 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56353 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56354 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56355 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56356 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56357 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56358 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56359 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56360 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56361 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56362 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56363 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56364 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56365 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56366 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56367 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56368 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56369 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56370 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56371 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56372 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56373 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56374 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56375 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56376 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56377 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56378 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56379 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56380 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56381 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56382 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56383 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56384 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56385 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56386 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56387 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56388 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56389 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56390 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56391 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56392 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56393 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56394 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56395 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56396 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56397 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56398 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56399 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56400 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56401 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56402 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56403 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56404 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56405 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56406 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56407 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56408 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56409 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56410 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56411 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56412 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56413 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56414 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56415 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56416 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56417 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56418 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56419 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56420 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56421 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56422 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56423 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56424 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56425 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56426 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56427 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56428 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56429 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56430 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56431 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56432 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56433 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56434 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56435 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56436 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56437 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56438 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56439 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56440 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56441 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56442 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56443 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56444 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56445 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56446 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56447 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56448 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56449 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56450 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56451 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56452 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56453 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56454 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56455 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56456 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56457 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56458 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56459 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56460 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56461 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56462 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56463 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56464 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56465 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56466 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56467 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56468 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56469 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56470 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56471 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56472 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56473 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56474 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56475 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56476 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56477 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56478 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56479 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56480 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56481 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56482 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56483 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56484 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56485 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56486 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56487 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56488 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56489 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56490 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56491 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56492 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56493 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56494 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56495 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56496 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56497 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56498 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56499 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56500 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56501 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56502 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56503 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56504 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56505 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56506 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56507 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56508 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56509 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56510 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56511 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56512 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56513 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56514 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56515 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56516 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56517 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56518 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56519 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56520 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56521 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56522 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56523 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56524 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56525 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56526 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56527 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56528 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56529 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56530 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56531 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56532 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56533 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56534 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56535 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56536
56537 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56538
56539
56540 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56541
56542 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56543 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56544 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56545 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56546 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56547 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56548 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56549 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56550 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56551 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56552 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56553 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56554 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56555 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56556 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56557 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56558 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56559 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56560 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56561 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56562 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56563 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56564 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56565 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56566 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56567 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56568 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56569 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56570 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56571 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56572 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56573 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56574 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56575 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56576 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56577 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56578 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56579 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56580 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56581 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56582 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56583 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56584 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56585 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56586 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56587 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56588 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56589 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56590 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56591 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56592 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56593 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56594 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56595 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56596 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56597 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56598 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56599 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56600 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56601 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56602 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56603 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56604 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56605 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56606 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56607 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56608 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56609 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56610 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56611 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56612 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56613 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56614 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56615 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56616 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56617 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56618 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56619 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56620 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56621 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56622 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56623 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56624 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56625 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56626 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56627 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56628 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56629 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56630 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56631 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56632 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56633 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56634 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56635 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56636 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56637 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56638 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56639 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56640 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56641 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56642 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56643 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56644 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56645 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56646 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56647 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56648 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56649 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56650 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56651 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56652 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56653 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56654 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56655 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56656 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56657 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56658 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56659 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56660 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56661 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56662 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56663 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56664 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56665 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56666 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56667 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56668 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56669 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56670 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56671 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56672 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56673 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56674 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56675 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56676 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56677 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56678 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56679 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56680 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56681 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56682 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56683 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56684 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56685 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56686 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56687 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56688 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56689 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56690 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56691 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56692 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56693 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56694 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56695 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56696 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56697 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56698 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56699 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56700 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56701 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56702 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56703 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56704 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56705 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56706 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56707 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56708 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56709 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56710 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56711 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56712 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56713 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56714 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56715 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56716 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56717 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56718 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56719 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56720 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56721 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56722 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56723 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56724 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56725 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56726 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56727 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56728 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56729 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56730 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56731 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56732 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56733 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56734 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56735 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56736 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56737 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56738 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56739 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56740 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56741 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56742 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56743 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56744 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56745 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56746 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56747 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56748
56749 // Initialize threading, some globals and such
56750 __wxPyPreStart(d);
56751
56752
56753 // Although these are defined in __version__ they need to be here too so
56754 // that an assert can be done to ensure that the wxPython and the wxWindows
56755 // versions match.
56756 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56757 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56758 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56759
56760 }
56761
wxWidgets (Impactor)